1 
// GENERATED BY ISLE. DO NOT EDIT!
2 
//
3 
// Generated automatically from the instruction-selection DSL code in:
4 
// - src/prelude.isle
5 
// - src/prelude_opt.isle
6 
// - src/opts/algebraic.isle
7 
// - src/opts/icmp.isle
8 
// - src/opts/cprop.isle
9 
// - /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle
10 

            

        

            

                11
            

            

                
            

            

                
use super::*; // Pulls in all external types.

            

        

            

                12
            

            

                
            

            

                
use std::marker::PhantomData;

            

        

            

                13
            

            

                
            

            

                

            

        

            

                14
            

            

                
            

            

                
/// Context during lowering: an implementation of this trait

            

        

            

                15
            

            

                
            

            

                
/// must be provided with all external constructors and extractors.

            

        

            

                16
            

            

                
            

            

                
/// A mutable borrow is passed along through all lowering logic.

            

        

            

                17
            

            

                
            

            

                
pub trait Context {

            

        

            

                18
            

            

                
            

            

                
    fn unit(&mut self) -> Unit;

            

        

            

                19
            

            

                
            

            

                
    fn value_type(&mut self, arg0: Value) -> Type;

            

        

            

                20
            

            

                
            

            

                
    fn u32_nonnegative(&mut self, arg0: u32) -> Option<u32>;

            

        

            

                21
            

            

                
            

            

                
    fn offset32(&mut self, arg0: Offset32) -> u32;

            

        

            

                22
            

            

                
            

            

                
    fn u32_lteq(&mut self, arg0: u32, arg1: u32) -> Option<Unit>;

            

        

            

                23
            

            

                
            

            

                
    fn u8_lteq(&mut self, arg0: u8, arg1: u8) -> Option<Unit>;

            

        

            

                24
            

            

                
            

            

                
    fn u8_lt(&mut self, arg0: u8, arg1: u8) -> Option<Unit>;

            

        

            

                25
            

            

                
            

            

                
    fn simm32(&mut self, arg0: Imm64) -> Option<u32>;

            

        

            

                26
            

            

                
            

            

                
    fn uimm8(&mut self, arg0: Imm64) -> Option<u8>;

            

        

            

                27
            

            

                
            

            

                
    fn u8_as_u32(&mut self, arg0: u8) -> u32;

            

        

            

                28
            

            

                
            

            

                
    fn u8_as_u64(&mut self, arg0: u8) -> u64;

            

        

            

                29
            

            

                
            

            

                
    fn u16_as_u64(&mut self, arg0: u16) -> u64;

            

        

            

                30
            

            

                
            

            

                
    fn u32_as_u64(&mut self, arg0: u32) -> u64;

            

        

            

                31
            

            

                
            

            

                
    fn i64_as_u64(&mut self, arg0: i64) -> u64;

            

        

            

                32
            

            

                
            

            

                
    fn i64_neg(&mut self, arg0: i64) -> i64;

            

        

            

                33
            

            

                
            

            

                
    fn u128_as_u64(&mut self, arg0: u128) -> Option<u64>;

            

        

            

                34
            

            

                
            

            

                
    fn u64_as_u32(&mut self, arg0: u64) -> Option<u32>;

            

        

            

                35
            

            

                
            

            

                
    fn u64_as_i32(&mut self, arg0: u64) -> i32;

            

        

            

                36
            

            

                
            

            

                
    fn u8_and(&mut self, arg0: u8, arg1: u8) -> u8;

            

        

            

                37
            

            

                
            

            

                
    fn u32_add(&mut self, arg0: u32, arg1: u32) -> u32;

            

        

            

                38
            

            

                
            

            

                
    fn s32_add_fallible(&mut self, arg0: u32, arg1: u32) -> Option<u32>;

            

        

            

                39
            

            

                
            

            

                
    fn u64_add(&mut self, arg0: u64, arg1: u64) -> u64;

            

        

            

                40
            

            

                
            

            

                
    fn u64_sub(&mut self, arg0: u64, arg1: u64) -> u64;

            

        

            

                41
            

            

                
            

            

                
    fn u64_mul(&mut self, arg0: u64, arg1: u64) -> u64;

            

        

            

                42
            

            

                
            

            

                
    fn u64_sdiv(&mut self, arg0: u64, arg1: u64) -> Option<u64>;

            

        

            

                43
            

            

                
            

            

                
    fn u64_udiv(&mut self, arg0: u64, arg1: u64) -> Option<u64>;

            

        

            

                44
            

            

                
            

            

                
    fn u64_and(&mut self, arg0: u64, arg1: u64) -> u64;

            

        

            

                45
            

            

                
            

            

                
    fn u64_or(&mut self, arg0: u64, arg1: u64) -> u64;

            

        

            

                46
            

            

                
            

            

                
    fn u64_xor(&mut self, arg0: u64, arg1: u64) -> u64;

            

        

            

                47
            

            

                
            

            

                
    fn u64_shl(&mut self, arg0: u64, arg1: u64) -> u64;

            

        

            

                48
            

            

                
            

            

                
    fn imm64_shl(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;

            

        

            

                49
            

            

                
            

            

                
    fn imm64_ushr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;

            

        

            

                50
            

            

                
            

            

                
    fn imm64_sshr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;

            

        

            

                51
            

            

                
            

            

                
    fn u64_not(&mut self, arg0: u64) -> u64;

            

        

            

                52
            

            

                
            

            

                
    fn u64_eq(&mut self, arg0: u64, arg1: u64) -> bool;

            

        

            

                53
            

            

                
            

            

                
    fn u64_le(&mut self, arg0: u64, arg1: u64) -> bool;

            

        

            

                54
            

            

                
            

            

                
    fn u64_lt(&mut self, arg0: u64, arg1: u64) -> bool;

            

        

            

                55
            

            

                
            

            

                
    fn i64_sextend_imm64(&mut self, arg0: Type, arg1: Imm64) -> i64;

            

        

            

                56
            

            

                
            

            

                
    fn u64_uextend_imm64(&mut self, arg0: Type, arg1: Imm64) -> u64;

            

        

            

                57
            

            

                
            

            

                
    fn imm64_icmp(&mut self, arg0: Type, arg1: &IntCC, arg2: Imm64, arg3: Imm64) -> Imm64;

            

        

            

                58
            

            

                
            

            

                
    fn u64_is_zero(&mut self, arg0: u64) -> bool;

            

        

            

                59
            

            

                
            

            

                
    fn u64_is_odd(&mut self, arg0: u64) -> bool;

            

        

            

                60
            

            

                
            

            

                
    fn ty_umin(&mut self, arg0: Type) -> u64;

            

        

            

                61
            

            

                
            

            

                
    fn ty_umax(&mut self, arg0: Type) -> u64;

            

        

            

                62
            

            

                
            

            

                
    fn ty_smin(&mut self, arg0: Type) -> u64;

            

        

            

                63
            

            

                
            

            

                
    fn ty_smax(&mut self, arg0: Type) -> u64;

            

        

            

                64
            

            

                
            

            

                
    fn ty_bits(&mut self, arg0: Type) -> u8;

            

        

            

                65
            

            

                
            

            

                
    fn ty_bits_u16(&mut self, arg0: Type) -> u16;

            

        

            

                66
            

            

                
            

            

                
    fn ty_bits_u64(&mut self, arg0: Type) -> u64;

            

        

            

                67
            

            

                
            

            

                
    fn ty_mask(&mut self, arg0: Type) -> u64;

            

        

            

                68
            

            

                
            

            

                
    fn ty_bytes(&mut self, arg0: Type) -> u16;

            

        

            

                69
            

            

                
            

            

                
    fn lane_type(&mut self, arg0: Type) -> Type;

            

        

            

                70
            

            

                
            

            

                
    fn mem_flags_trusted(&mut self) -> MemFlags;

            

        

            

                71
            

            

                
            

            

                
    fn intcc_reverse(&mut self, arg0: &IntCC) -> IntCC;

            

        

            

                72
            

            

                
            

            

                
    fn intcc_inverse(&mut self, arg0: &IntCC) -> IntCC;

            

        

            

                73
            

            

                
            

            

                
    fn floatcc_reverse(&mut self, arg0: &FloatCC) -> FloatCC;

            

        

            

                74
            

            

                
            

            

                
    fn floatcc_inverse(&mut self, arg0: &FloatCC) -> FloatCC;

            

        

            

                75
            

            

                
            

            

                
    fn floatcc_unordered(&mut self, arg0: &FloatCC) -> bool;

            

        

            

                76
            

            

                
            

            

                
    fn fits_in_16(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                77
            

            

                
            

            

                
    fn fits_in_32(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                78
            

            

                
            

            

                
    fn lane_fits_in_32(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                79
            

            

                
            

            

                
    fn fits_in_64(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                80
            

            

                
            

            

                
    fn ty_32(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                81
            

            

                
            

            

                
    fn ty_64(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                82
            

            

                
            

            

                
    fn ty_int_ref_scalar_64(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                83
            

            

                
            

            

                
    fn ty_32_or_64(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                84
            

            

                
            

            

                
    fn ty_8_or_16(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                85
            

            

                
            

            

                
    fn int_fits_in_32(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                86
            

            

                
            

            

                
    fn ty_int_ref_64(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                87
            

            

                
            

            

                
    fn ty_int(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                88
            

            

                
            

            

                
    fn ty_scalar_float(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                89
            

            

                
            

            

                
    fn ty_float_or_vec(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                90
            

            

                
            

            

                
    fn ty_vector_float(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                91
            

            

                
            

            

                
    fn ty_vector_not_float(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                92
            

            

                
            

            

                
    fn ty_vec64(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                93
            

            

                
            

            

                
    fn ty_vec64_ctor(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                94
            

            

                
            

            

                
    fn ty_vec128(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                95
            

            

                
            

            

                
    fn ty_dyn_vec64(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                96
            

            

                
            

            

                
    fn ty_dyn_vec128(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                97
            

            

                
            

            

                
    fn ty_vec64_int(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                98
            

            

                
            

            

                
    fn ty_vec128_int(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                99
            

            

                
            

            

                
    fn ty_addr64(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                100
            

            

                
            

            

                
    fn not_vec32x2(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                101
            

            

                
            

            

                
    fn not_i64x2(&mut self, arg0: Type) -> Option<()>;

            

        

            

                102
            

            

                
            

            

                
    fn u8_from_uimm8(&mut self, arg0: Uimm8) -> u8;

            

        

            

                103
            

            

                
            

            

                
    fn u64_from_bool(&mut self, arg0: bool) -> u64;

            

        

            

                104
            

            

                
            

            

                
    fn u64_from_imm64(&mut self, arg0: Imm64) -> u64;

            

        

            

                105
            

            

                
            

            

                
    fn nonzero_u64_from_imm64(&mut self, arg0: Imm64) -> Option<u64>;

            

        

            

                106
            

            

                
            

            

                
    fn imm64_power_of_two(&mut self, arg0: Imm64) -> Option<u64>;

            

        

            

                107
            

            

                
            

            

                
    fn imm64(&mut self, arg0: u64) -> Imm64;

            

        

            

                108
            

            

                
            

            

                
    fn imm64_masked(&mut self, arg0: Type, arg1: u64) -> Imm64;

            

        

            

                109
            

            

                
            

            

                
    fn u32_from_ieee32(&mut self, arg0: Ieee32) -> u32;

            

        

            

                110
            

            

                
            

            

                
    fn u64_from_ieee64(&mut self, arg0: Ieee64) -> u64;

            

        

            

                111
            

            

                
            

            

                
    fn multi_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;

            

        

            

                112
            

            

                
            

            

                
    fn dynamic_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;

            

        

            

                113
            

            

                
            

            

                
    fn dynamic_int_lane(&mut self, arg0: Type) -> Option<u32>;

            

        

            

                114
            

            

                
            

            

                
    fn dynamic_fp_lane(&mut self, arg0: Type) -> Option<u32>;

            

        

            

                115
            

            

                
            

            

                
    fn ty_dyn64_int(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                116
            

            

                
            

            

                
    fn ty_dyn128_int(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                117
            

            

                
            

            

                
    fn offset32_to_u32(&mut self, arg0: Offset32) -> u32;

            

        

            

                118
            

            

                
            

            

                
    fn u32_to_offset32(&mut self, arg0: u32) -> Offset32;

            

        

            

                119
            

            

                
            

            

                
    fn intcc_unsigned(&mut self, arg0: &IntCC) -> IntCC;

            

        

            

                120
            

            

                
            

            

                
    fn signed_cond_code(&mut self, arg0: &IntCC) -> Option<IntCC>;

            

        

            

                121
            

            

                
            

            

                
    fn trap_code_division_by_zero(&mut self) -> TrapCode;

            

        

            

                122
            

            

                
            

            

                
    fn trap_code_integer_overflow(&mut self) -> TrapCode;

            

        

            

                123
            

            

                
            

            

                
    fn trap_code_bad_conversion_to_integer(&mut self) -> TrapCode;

            

        

            

                124
            

            

                
            

            

                
    fn range(&mut self, arg0: usize, arg1: usize) -> Range;

            

        

            

                125
            

            

                
            

            

                
    fn range_view(&mut self, arg0: Range) -> RangeView;

            

        

            

                126
            

            

                
            

            

                
    type inst_data_etor_iter: ContextIter<Context = Self, Output = (Type, InstructionData)>;

            

        

            

                127
            

            

                
            

            

                
    fn inst_data_etor(&mut self, arg0: Value) -> Self::inst_data_etor_iter;

            

        

            

                128
            

            

                
            

            

                
    fn make_inst_ctor(&mut self, arg0: Type, arg1: &InstructionData) -> Value;

            

        

            

                129
            

            

                
            

            

                
    fn value_array_2_ctor(&mut self, arg0: Value, arg1: Value) -> ValueArray2;

            

        

            

                130
            

            

                
            

            

                
    fn value_array_3_ctor(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3;

            

        

            

                131
            

            

                
            

            

                
    fn remat(&mut self, arg0: Value) -> Value;

            

        

            

                132
            

            

                
            

            

                
    fn subsume(&mut self, arg0: Value) -> Value;

            

        

            

                133
            

            

                
            

            

                
    fn unpack_value_array_2(&mut self, arg0: &ValueArray2) -> (Value, Value);

            

        

            

                134
            

            

                
            

            

                
    fn pack_value_array_2(&mut self, arg0: Value, arg1: Value) -> ValueArray2;

            

        

            

                135
            

            

                
            

            

                
    fn unpack_value_array_3(&mut self, arg0: &ValueArray3) -> (Value, Value, Value);

            

        

            

                136
            

            

                
            

            

                
    fn pack_value_array_3(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3;

            

        

            

                137
            

            

                
            

            

                
    fn unpack_block_array_2(&mut self, arg0: &BlockArray2) -> (BlockCall, BlockCall);

            

        

            

                138
            

            

                
            

            

                
    fn pack_block_array_2(&mut self, arg0: BlockCall, arg1: BlockCall) -> BlockArray2;

            

        

            

                139
            

            

                
            

            

                
}

            

        

            

                140
            

            

                
            

            

                

            

        

            

                141
            

            

                
            

            

                
pub trait ContextIter {

            

        

            

                142
            

            

                
            

            

                
    type Context;

            

        

            

                143
            

            

                
            

            

                
    type Output;

            

        

            

                144
            

            

                
            

            

                
    fn next(&mut self, ctx: &mut Self::Context) -> Option<Self::Output>;

            

        

            

                145
            

            

                
            

            

                
}

            

        

            

                146
            

            

                
            

            

                

            

        

            

                147
            

            

                
            

            

                
pub struct ContextIterWrapper<Item, I: Iterator<Item = Item>, C: Context> {

            

        

            

                148
            

            

                
            

            

                
    iter: I,

            

        

            

                149
            

            

                
            

            

                
    _ctx: PhantomData<C>,

            

        

            

                150
            

            

                
            

            

                
}

            

        

            

                151
            

            

                
            

            

                
impl<Item, I: Iterator<Item = Item>, C: Context> From<I> for ContextIterWrapper<Item, I, C> {

            

        

            

                152
            

            

                
            

            

                
    fn from(iter: I) -> Self {

            

        

            

                153
            

            

                
            

            

                
        Self {

            

        

            

                154
            

            

                
            

            

                
            iter,

            

        

            

                155
            

            

                
            

            

                
            _ctx: PhantomData,

            

        

            

                156
            

            

                
            

            

                
        }

            

        

            

                157
            

            

                
            

            

                
    }

            

        

            

                158
            

            

                
            

            

                
}

            

        

            

                159
            

            

                
            

            

                
impl<Item, I: Iterator<Item = Item>, C: Context> ContextIter for ContextIterWrapper<Item, I, C> {

            

        

            

                160
            

            

                
            

            

                
    type Context = C;

            

        

            

                161
            

            

                
            

            

                
    type Output = Item;

            

        

            

                162
            

            

                
            

            

                
    fn next(&mut self, _ctx: &mut Self::Context) -> Option<Self::Output> {

            

        

            

                163
            

            

                
            

            

                
        self.iter.next()

            

        

            

                164
            

            

                
            

            

                
    }

            

        

            

                165
            

            

                
            

            

                
}

            

        

            

                166
            

            

                
            

            

                

            

        

            

                167
            

            

                
            

            

                
// Generated as internal constructor for term eq.

            

        

            

                168
            

            

                
            

            

                
pub fn constructor_eq<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                169
            

            

                
            

            

                
    let v4 = constructor_icmp(ctx, arg0, &IntCC::Equal, arg1, arg2);

            

        

            

                170
            

            

                
            

            

                
    // Rule at src/prelude_opt.isle line 20.

            

        

            

                171
            

            

                
            

            

                
    return v4;

            

        

            

                172
            

            

                
            

            

                
}

            

        

            

                173
            

            

                
            

            

                

            

        

            

                174
            

            

                
            

            

                
// Generated as internal constructor for term ne.

            

        

            

                175
            

            

                
            

            

                
pub fn constructor_ne<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                176
            

            

                
            

            

                
    let v4 = constructor_icmp(ctx, arg0, &IntCC::NotEqual, arg1, arg2);

            

        

            

                177
            

            

                
            

            

                
    // Rule at src/prelude_opt.isle line 21.

            

        

            

                178
            

            

                
            

            

                
    return v4;

            

        

            

                179
            

            

                
            

            

                
}

            

        

            

                180
            

            

                
            

            

                

            

        

            

                181
            

            

                
            

            

                
// Generated as internal constructor for term ult.

            

        

            

                182
            

            

                
            

            

                
pub fn constructor_ult<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                183
            

            

                
            

            

                
    let v4 = constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThan, arg1, arg2);

            

        

            

                184
            

            

                
            

            

                
    // Rule at src/prelude_opt.isle line 22.

            

        

            

                185
            

            

                
            

            

                
    return v4;

            

        

            

                186
            

            

                
            

            

                
}

            

        

            

                187
            

            

                
            

            

                

            

        

            

                188
            

            

                
            

            

                
// Generated as internal constructor for term ule.

            

        

            

                189
            

            

                
            

            

                
pub fn constructor_ule<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                190
            

            

                
            

            

                
    let v4 = constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThanOrEqual, arg1, arg2);

            

        

            

                191
            

            

                
            

            

                
    // Rule at src/prelude_opt.isle line 23.

            

        

            

                192
            

            

                
            

            

                
    return v4;

            

        

            

                193
            

            

                
            

            

                
}

            

        

            

                194
            

            

                
            

            

                

            

        

            

                195
            

            

                
            

            

                
// Generated as internal constructor for term ugt.

            

        

            

                196
            

            

                
            

            

                
pub fn constructor_ugt<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                197
            

            

                
            

            

                
    let v4 = constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThan, arg1, arg2);

            

        

            

                198
            

            

                
            

            

                
    // Rule at src/prelude_opt.isle line 24.

            

        

            

                199
            

            

                
            

            

                
    return v4;

            

        

            

                200
            

            

                
            

            

                
}

            

        

            

                201
            

            

                
            

            

                

            

        

            

                202
            

            

                
            

            

                
// Generated as internal constructor for term uge.

            

        

            

                203
            

            

                
            

            

                
pub fn constructor_uge<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                204
            

            

                
            

            

                
    let v4 = constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThanOrEqual, arg1, arg2);

            

        

            

                205
            

            

                
            

            

                
    // Rule at src/prelude_opt.isle line 25.

            

        

            

                206
            

            

                
            

            

                
    return v4;

            

        

            

                207
            

            

                
            

            

                
}

            

        

            

                208
            

            

                
            

            

                

            

        

            

                209
            

            

                
            

            

                
// Generated as internal constructor for term slt.

            

        

            

                210
            

            

                
            

            

                
pub fn constructor_slt<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                211
            

            

                
            

            

                
    let v4 = constructor_icmp(ctx, arg0, &IntCC::SignedLessThan, arg1, arg2);

            

        

            

                212
            

            

                
            

            

                
    // Rule at src/prelude_opt.isle line 26.

            

        

            

                213
            

            

                
            

            

                
    return v4;

            

        

            

                214
            

            

                
            

            

                
}

            

        

            

                215
            

            

                
            

            

                

            

        

            

                216
            

            

                
            

            

                
// Generated as internal constructor for term sle.

            

        

            

                217
            

            

                
            

            

                
pub fn constructor_sle<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                218
            

            

                
            

            

                
    let v4 = constructor_icmp(ctx, arg0, &IntCC::SignedLessThanOrEqual, arg1, arg2);

            

        

            

                219
            

            

                
            

            

                
    // Rule at src/prelude_opt.isle line 27.

            

        

            

                220
            

            

                
            

            

                
    return v4;

            

        

            

                221
            

            

                
            

            

                
}

            

        

            

                222
            

            

                
            

            

                

            

        

            

                223
            

            

                
            

            

                
// Generated as internal constructor for term sgt.

            

        

            

                224
            

            

                
            

            

                
pub fn constructor_sgt<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                225
            

            

                
            

            

                
    let v4 = constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThan, arg1, arg2);

            

        

            

                226
            

            

                
            

            

                
    // Rule at src/prelude_opt.isle line 28.

            

        

            

                227
            

            

                
            

            

                
    return v4;

            

        

            

                228
            

            

                
            

            

                
}

            

        

            

                229
            

            

                
            

            

                

            

        

            

                230
            

            

                
            

            

                
// Generated as internal constructor for term sge.

            

        

            

                231
            

            

                
            

            

                
pub fn constructor_sge<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                232
            

            

                
            

            

                
    let v4 = constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThanOrEqual, arg1, arg2);

            

        

            

                233
            

            

                
            

            

                
    // Rule at src/prelude_opt.isle line 29.

            

        

            

                234
            

            

                
            

            

                
    return v4;

            

        

            

                235
            

            

                
            

            

                
}

            

        

            

                236
            

            

                
            

            

                

            

        

            

                237
            

            

                
            

            

                
// Generated as internal constructor for term simplify.

            

        

            

                238
            

            

                
            

            

                
pub fn constructor_simplify<C: Context>(

            

        

            

                239
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                240
            

            

                
            

            

                
    arg0: Value,

            

        

            

                241
            

            

                
            

            

                
) -> impl ContextIter<Context = C, Output = Value> {

            

        

            

                242
            

            

                
            

            

                
    let mut returns = ConstructorVec::new();

            

        

            

                243
            

            

                
            

            

                
    let v1 = C::inst_data_etor(ctx, arg0);

            

        

            

                244
            

            

                
            

            

                
    let mut v1 = v1;

            

        

            

                245
            

            

                
            

            

                
    while let Some(v2) = v1.next(ctx) {

            

        

            

                246
            

            

                
            

            

                
        match &v2.1 {

            

        

            

                247
            

            

                
            

            

                
            &InstructionData::Binary {

            

        

            

                248
            

            

                
            

            

                
                opcode: ref v15,

            

        

            

                249
            

            

                
            

            

                
                args: ref v16,

            

        

            

                250
            

            

                
            

            

                
            } => {

            

        

            

                251
            

            

                
            

            

                
                match v15 {

            

        

            

                252
            

            

                
            

            

                
                    &Opcode::Iadd => {

            

        

            

                253
            

            

                
            

            

                
                        let v17 = C::unpack_value_array_2(ctx, v16);

            

        

            

                254
            

            

                
            

            

                
                        let v28 = C::inst_data_etor(ctx, v17.0);

            

        

            

                255
            

            

                
            

            

                
                        let mut v28 = v28;

            

        

            

                256
            

            

                
            

            

                
                        while let Some(v29) = v28.next(ctx) {

            

        

            

                257
            

            

                
            

            

                
                            match &v29.1 {

            

        

            

                258
            

            

                
            

            

                
                                &InstructionData::Binary {

            

        

            

                259
            

            

                
            

            

                
                                    opcode: ref v70,

            

        

            

                260
            

            

                
            

            

                
                                    args: ref v71,

            

        

            

                261
            

            

                
            

            

                
                                } => {

            

        

            

                262
            

            

                
            

            

                
                                    match v70 {

            

        

            

                263
            

            

                
            

            

                
                                        &Opcode::Iadd => {

            

        

            

                264
            

            

                
            

            

                
                                            if v2.0 == v29.0 {

            

        

            

                265
            

            

                
            

            

                
                                                let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                266
            

            

                
            

            

                
                                                let mut v20 = v20;

            

        

            

                267
            

            

                
            

            

                
                                                while let Some(v21) = v20.next(ctx) {

            

        

            

                268
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                269
            

            

                
            

            

                
                                                        opcode: ref v24,

            

        

            

                270
            

            

                
            

            

                
                                                        imm: v25,

            

        

            

                271
            

            

                
            

            

                
                                                    } = &v21.1

            

        

            

                272
            

            

                
            

            

                
                                                    {

            

        

            

                273
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v24 {

            

        

            

                274
            

            

                
            

            

                
                                                            if v2.0 == v21.0 {

            

        

            

                275
            

            

                
            

            

                
                                                                let v72 = C::unpack_value_array_2(

            

        

            

                276
            

            

                
            

            

                
                                                                    ctx, v71,

            

        

            

                277
            

            

                
            

            

                
                                                                );

            

        

            

                278
            

            

                
            

            

                
                                                                let v82 =

            

        

            

                279
            

            

                
            

            

                
                                                                    C::inst_data_etor(ctx, v72.1);

            

        

            

                280
            

            

                
            

            

                
                                                                let mut v82 = v82;

            

        

            

                281
            

            

                
            

            

                
                                                                while let Some(v83) = v82.next(ctx)

            

        

            

                282
            

            

                
            

            

                
                                                                {

            

        

            

                283
            

            

                
            

            

                
                                                                    if let &InstructionData::UnaryImm {

            

        

            

                284
            

            

                
            

            

                
                                                                        opcode: ref v86,

            

        

            

                285
            

            

                
            

            

                
                                                                        imm: v87,

            

        

            

                286
            

            

                
            

            

                
                                                                    } = &v83.1 {

            

        

            

                287
            

            

                
            

            

                
                                                                        if let &Opcode::Iconst = v86 {

            

        

            

                288
            

            

                
            

            

                
                                                                            if v2.0 == v83.0 {

            

        

            

                289
            

            

                
            

            

                
                                                                                let v352 = constructor_iadd(ctx, v2.0, v72.1, v17.1);

            

        

            

                290
            

            

                
            

            

                
                                                                                let v353 = constructor_iadd(ctx, v2.0, v72.0, v352);

            

        

            

                291
            

            

                
            

            

                
                                                                                // Rule at src/opts/cprop.isle line 122.

            

        

            

                292
            

            

                
            

            

                
                                                                                returns.push(v353);

            

        

            

                293
            

            

                
            

            

                
                                                                            }

            

        

            

                294
            

            

                
            

            

                
                                                                        }

            

        

            

                295
            

            

                
            

            

                
                                                                    }

            

        

            

                296
            

            

                
            

            

                
                                                                }

            

        

            

                297
            

            

                
            

            

                
                                                            }

            

        

            

                298
            

            

                
            

            

                
                                                        }

            

        

            

                299
            

            

                
            

            

                
                                                    }

            

        

            

                300
            

            

                
            

            

                
                                                }

            

        

            

                301
            

            

                
            

            

                
                                            }

            

        

            

                302
            

            

                
            

            

                
                                        }

            

        

            

                303
            

            

                
            

            

                
                                        &Opcode::Isub => {

            

        

            

                304
            

            

                
            

            

                
                                            if v2.0 == v29.0 {

            

        

            

                305
            

            

                
            

            

                
                                                let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                306
            

            

                
            

            

                
                                                let mut v20 = v20;

            

        

            

                307
            

            

                
            

            

                
                                                while let Some(v21) = v20.next(ctx) {

            

        

            

                308
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                309
            

            

                
            

            

                
                                                        opcode: ref v24,

            

        

            

                310
            

            

                
            

            

                
                                                        imm: v25,

            

        

            

                311
            

            

                
            

            

                
                                                    } = &v21.1

            

        

            

                312
            

            

                
            

            

                
                                                    {

            

        

            

                313
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v24 {

            

        

            

                314
            

            

                
            

            

                
                                                            if v2.0 == v21.0 {

            

        

            

                315
            

            

                
            

            

                
                                                                let v72 = C::unpack_value_array_2(

            

        

            

                316
            

            

                
            

            

                
                                                                    ctx, v71,

            

        

            

                317
            

            

                
            

            

                
                                                                );

            

        

            

                318
            

            

                
            

            

                
                                                                let v82 =

            

        

            

                319
            

            

                
            

            

                
                                                                    C::inst_data_etor(ctx, v72.1);

            

        

            

                320
            

            

                
            

            

                
                                                                let mut v82 = v82;

            

        

            

                321
            

            

                
            

            

                
                                                                while let Some(v83) = v82.next(ctx)

            

        

            

                322
            

            

                
            

            

                
                                                                {

            

        

            

                323
            

            

                
            

            

                
                                                                    if let &InstructionData::UnaryImm {

            

        

            

                324
            

            

                
            

            

                
                                                                        opcode: ref v86,

            

        

            

                325
            

            

                
            

            

                
                                                                        imm: v87,

            

        

            

                326
            

            

                
            

            

                
                                                                    } = &v83.1 {

            

        

            

                327
            

            

                
            

            

                
                                                                        if let &Opcode::Iconst = v86 {

            

        

            

                328
            

            

                
            

            

                
                                                                            if v2.0 == v83.0 {

            

        

            

                329
            

            

                
            

            

                
                                                                                let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                330
            

            

                
            

            

                
                                                                                let v88 = C::u64_from_imm64(ctx, v87);

            

        

            

                331
            

            

                
            

            

                
                                                                                let v365 = C::u64_sub(ctx, v26, v88);

            

        

            

                332
            

            

                
            

            

                
                                                                                let v366 = C::imm64_masked(ctx, v2.0, v365);

            

        

            

                333
            

            

                
            

            

                
                                                                                let v367 = constructor_iconst(ctx, v2.0, v366);

            

        

            

                334
            

            

                
            

            

                
                                                                                let v369 = constructor_iadd(ctx, v2.0, v72.0, v367);

            

        

            

                335
            

            

                
            

            

                
                                                                                // Rule at src/opts/cprop.isle line 144.

            

        

            

                336
            

            

                
            

            

                
                                                                                returns.push(v369);

            

        

            

                337
            

            

                
            

            

                
                                                                            }

            

        

            

                338
            

            

                
            

            

                
                                                                        }

            

        

            

                339
            

            

                
            

            

                
                                                                    }

            

        

            

                340
            

            

                
            

            

                
                                                                }

            

        

            

                341
            

            

                
            

            

                
                                                                let v118 =

            

        

            

                342
            

            

                
            

            

                
                                                                    C::inst_data_etor(ctx, v72.0);

            

        

            

                343
            

            

                
            

            

                
                                                                let mut v118 = v118;

            

        

            

                344
            

            

                
            

            

                
                                                                while let Some(v119) =

            

        

            

                345
            

            

                
            

            

                
                                                                    v118.next(ctx)

            

        

            

                346
            

            

                
            

            

                
                                                                {

            

        

            

                347
            

            

                
            

            

                
                                                                    if let &InstructionData::UnaryImm {

            

        

            

                348
            

            

                
            

            

                
                                                                        opcode: ref v358,

            

        

            

                349
            

            

                
            

            

                
                                                                        imm: v359,

            

        

            

                350
            

            

                
            

            

                
                                                                    } = &v119.1 {

            

        

            

                351
            

            

                
            

            

                
                                                                        if let &Opcode::Iconst = v358 {

            

        

            

                352
            

            

                
            

            

                
                                                                            if v2.0 == v119.0 {

            

        

            

                353
            

            

                
            

            

                
                                                                                let v360 = C::u64_from_imm64(ctx, v359);

            

        

            

                354
            

            

                
            

            

                
                                                                                let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                355
            

            

                
            

            

                
                                                                                let v370 = C::u64_add(ctx, v360, v26);

            

        

            

                356
            

            

                
            

            

                
                                                                                let v371 = C::imm64_masked(ctx, v2.0, v370);

            

        

            

                357
            

            

                
            

            

                
                                                                                let v372 = constructor_iconst(ctx, v2.0, v371);

            

        

            

                358
            

            

                
            

            

                
                                                                                let v373 = constructor_isub(ctx, v2.0, v372, v72.1);

            

        

            

                359
            

            

                
            

            

                
                                                                                // Rule at src/opts/cprop.isle line 148.

            

        

            

                360
            

            

                
            

            

                
                                                                                returns.push(v373);

            

        

            

                361
            

            

                
            

            

                
                                                                            }

            

        

            

                362
            

            

                
            

            

                
                                                                        }

            

        

            

                363
            

            

                
            

            

                
                                                                    }

            

        

            

                364
            

            

                
            

            

                
                                                                }

            

        

            

                365
            

            

                
            

            

                
                                                            }

            

        

            

                366
            

            

                
            

            

                
                                                        }

            

        

            

                367
            

            

                
            

            

                
                                                    }

            

        

            

                368
            

            

                
            

            

                
                                                }

            

        

            

                369
            

            

                
            

            

                
                                            }

            

        

            

                370
            

            

                
            

            

                
                                        }

            

        

            

                371
            

            

                
            

            

                
                                        _ => {}

            

        

            

                372
            

            

                
            

            

                
                                    }

            

        

            

                373
            

            

                
            

            

                
                                }

            

        

            

                374
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                375
            

            

                
            

            

                
                                    opcode: ref v32,

            

        

            

                376
            

            

                
            

            

                
                                    imm: v33,

            

        

            

                377
            

            

                
            

            

                
                                } => {

            

        

            

                378
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v32 {

            

        

            

                379
            

            

                
            

            

                
                                        if v2.0 == v29.0 {

            

        

            

                380
            

            

                
            

            

                
                                            let v34 = C::u64_from_imm64(ctx, v33);

            

        

            

                381
            

            

                
            

            

                
                                            if v34 == 0x0 {

            

        

            

                382
            

            

                
            

            

                
                                                let v35 = C::subsume(ctx, v17.1);

            

        

            

                383
            

            

                
            

            

                
                                                // Rule at src/opts/algebraic.isle line 20.

            

        

            

                384
            

            

                
            

            

                
                                                returns.push(v35);

            

        

            

                385
            

            

                
            

            

                
                                            }

            

        

            

                386
            

            

                
            

            

                
                                            let v343 = constructor_iadd(ctx, v2.0, v17.1, v17.0);

            

        

            

                387
            

            

                
            

            

                
                                            // Rule at src/opts/cprop.isle line 91.

            

        

            

                388
            

            

                
            

            

                
                                            returns.push(v343);

            

        

            

                389
            

            

                
            

            

                
                                        }

            

        

            

                390
            

            

                
            

            

                
                                        let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                391
            

            

                
            

            

                
                                        if let Some(v47) = v46 {

            

        

            

                392
            

            

                
            

            

                
                                            if v29.0 == v47 {

            

        

            

                393
            

            

                
            

            

                
                                                let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                394
            

            

                
            

            

                
                                                let mut v20 = v20;

            

        

            

                395
            

            

                
            

            

                
                                                while let Some(v21) = v20.next(ctx) {

            

        

            

                396
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                397
            

            

                
            

            

                
                                                        opcode: ref v24,

            

        

            

                398
            

            

                
            

            

                
                                                        imm: v25,

            

        

            

                399
            

            

                
            

            

                
                                                    } = &v21.1

            

        

            

                400
            

            

                
            

            

                
                                                    {

            

        

            

                401
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v24 {

            

        

            

                402
            

            

                
            

            

                
                                                            if v21.0 == v29.0 {

            

        

            

                403
            

            

                
            

            

                
                                                                let v34 =

            

        

            

                404
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v33);

            

        

            

                405
            

            

                
            

            

                
                                                                let v26 =

            

        

            

                406
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v25);

            

        

            

                407
            

            

                
            

            

                
                                                                let v279 =

            

        

            

                408
            

            

                
            

            

                
                                                                    C::u64_add(ctx, v34, v26);

            

        

            

                409
            

            

                
            

            

                
                                                                let v280 =

            

        

            

                410
            

            

                
            

            

                
                                                                    C::imm64_masked(ctx, v47, v279);

            

        

            

                411
            

            

                
            

            

                
                                                                let v281 = constructor_iconst(

            

        

            

                412
            

            

                
            

            

                
                                                                    ctx, v47, v280,

            

        

            

                413
            

            

                
            

            

                
                                                                );

            

        

            

                414
            

            

                
            

            

                
                                                                let v282 = C::subsume(ctx, v281);

            

        

            

                415
            

            

                
            

            

                
                                                                // Rule at src/opts/cprop.isle line 3.

            

        

            

                416
            

            

                
            

            

                
                                                                returns.push(v282);

            

        

            

                417
            

            

                
            

            

                
                                                            }

            

        

            

                418
            

            

                
            

            

                
                                                        }

            

        

            

                419
            

            

                
            

            

                
                                                    }

            

        

            

                420
            

            

                
            

            

                
                                                }

            

        

            

                421
            

            

                
            

            

                
                                            }

            

        

            

                422
            

            

                
            

            

                
                                        }

            

        

            

                423
            

            

                
            

            

                
                                        let v138 = C::remat(ctx, arg0);

            

        

            

                424
            

            

                
            

            

                
                                        // Rule at src/opts/algebraic.isle line 296.

            

        

            

                425
            

            

                
            

            

                
                                        returns.push(v138);

            

        

            

                426
            

            

                
            

            

                
                                    }

            

        

            

                427
            

            

                
            

            

                
                                }

            

        

            

                428
            

            

                
            

            

                
                                _ => {}

            

        

            

                429
            

            

                
            

            

                
                            }

            

        

            

                430
            

            

                
            

            

                
                        }

            

        

            

                431
            

            

                
            

            

                
                        let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                432
            

            

                
            

            

                
                        let mut v20 = v20;

            

        

            

                433
            

            

                
            

            

                
                        while let Some(v21) = v20.next(ctx) {

            

        

            

                434
            

            

                
            

            

                
                            if let &InstructionData::UnaryImm {

            

        

            

                435
            

            

                
            

            

                
                                opcode: ref v24,

            

        

            

                436
            

            

                
            

            

                
                                imm: v25,

            

        

            

                437
            

            

                
            

            

                
                            } = &v21.1

            

        

            

                438
            

            

                
            

            

                
                            {

            

        

            

                439
            

            

                
            

            

                
                                if let &Opcode::Iconst = v24 {

            

        

            

                440
            

            

                
            

            

                
                                    let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                441
            

            

                
            

            

                
                                    if v26 == 0x0 {

            

        

            

                442
            

            

                
            

            

                
                                        if v2.0 == v21.0 {

            

        

            

                443
            

            

                
            

            

                
                                            let v27 = C::subsume(ctx, v17.0);

            

        

            

                444
            

            

                
            

            

                
                                            // Rule at src/opts/algebraic.isle line 16.

            

        

            

                445
            

            

                
            

            

                
                                            returns.push(v27);

            

        

            

                446
            

            

                
            

            

                
                                        }

            

        

            

                447
            

            

                
            

            

                
                                    }

            

        

            

                448
            

            

                
            

            

                
                                    let v138 = C::remat(ctx, arg0);

            

        

            

                449
            

            

                
            

            

                
                                    // Rule at src/opts/algebraic.isle line 298.

            

        

            

                450
            

            

                
            

            

                
                                    returns.push(v138);

            

        

            

                451
            

            

                
            

            

                
                                }

            

        

            

                452
            

            

                
            

            

                
                            }

            

        

            

                453
            

            

                
            

            

                
                        }

            

        

            

                454
            

            

                
            

            

                
                    }

            

        

            

                455
            

            

                
            

            

                
                    &Opcode::Isub => {

            

        

            

                456
            

            

                
            

            

                
                        let v17 = C::unpack_value_array_2(ctx, v16);

            

        

            

                457
            

            

                
            

            

                
                        let v28 = C::inst_data_etor(ctx, v17.0);

            

        

            

                458
            

            

                
            

            

                
                        let mut v28 = v28;

            

        

            

                459
            

            

                
            

            

                
                        while let Some(v29) = v28.next(ctx) {

            

        

            

                460
            

            

                
            

            

                
                            match &v29.1 {

            

        

            

                461
            

            

                
            

            

                
                                &InstructionData::Binary {

            

        

            

                462
            

            

                
            

            

                
                                    opcode: ref v70,

            

        

            

                463
            

            

                
            

            

                
                                    args: ref v71,

            

        

            

                464
            

            

                
            

            

                
                                } => {

            

        

            

                465
            

            

                
            

            

                
                                    match v70 {

            

        

            

                466
            

            

                
            

            

                
                                        &Opcode::Iadd => {

            

        

            

                467
            

            

                
            

            

                
                                            if v2.0 == v29.0 {

            

        

            

                468
            

            

                
            

            

                
                                                let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                469
            

            

                
            

            

                
                                                let mut v20 = v20;

            

        

            

                470
            

            

                
            

            

                
                                                while let Some(v21) = v20.next(ctx) {

            

        

            

                471
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                472
            

            

                
            

            

                
                                                        opcode: ref v24,

            

        

            

                473
            

            

                
            

            

                
                                                        imm: v25,

            

        

            

                474
            

            

                
            

            

                
                                                    } = &v21.1

            

        

            

                475
            

            

                
            

            

                
                                                    {

            

        

            

                476
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v24 {

            

        

            

                477
            

            

                
            

            

                
                                                            if v2.0 == v21.0 {

            

        

            

                478
            

            

                
            

            

                
                                                                let v72 = C::unpack_value_array_2(

            

        

            

                479
            

            

                
            

            

                
                                                                    ctx, v71,

            

        

            

                480
            

            

                
            

            

                
                                                                );

            

        

            

                481
            

            

                
            

            

                
                                                                let v82 =

            

        

            

                482
            

            

                
            

            

                
                                                                    C::inst_data_etor(ctx, v72.1);

            

        

            

                483
            

            

                
            

            

                
                                                                let mut v82 = v82;

            

        

            

                484
            

            

                
            

            

                
                                                                while let Some(v83) = v82.next(ctx)

            

        

            

                485
            

            

                
            

            

                
                                                                {

            

        

            

                486
            

            

                
            

            

                
                                                                    if let &InstructionData::UnaryImm {

            

        

            

                487
            

            

                
            

            

                
                                                                        opcode: ref v86,

            

        

            

                488
            

            

                
            

            

                
                                                                        imm: v87,

            

        

            

                489
            

            

                
            

            

                
                                                                    } = &v83.1 {

            

        

            

                490
            

            

                
            

            

                
                                                                        if let &Opcode::Iconst = v86 {

            

        

            

                491
            

            

                
            

            

                
                                                                            if v2.0 == v83.0 {

            

        

            

                492
            

            

                
            

            

                
                                                                                let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                493
            

            

                
            

            

                
                                                                                let v88 = C::u64_from_imm64(ctx, v87);

            

        

            

                494
            

            

                
            

            

                
                                                                                let v365 = C::u64_sub(ctx, v26, v88);

            

        

            

                495
            

            

                
            

            

                
                                                                                let v366 = C::imm64_masked(ctx, v2.0, v365);

            

        

            

                496
            

            

                
            

            

                
                                                                                let v367 = constructor_iconst(ctx, v2.0, v366);

            

        

            

                497
            

            

                
            

            

                
                                                                                let v368 = constructor_isub(ctx, v2.0, v72.0, v367);

            

        

            

                498
            

            

                
            

            

                
                                                                                // Rule at src/opts/cprop.isle line 140.

            

        

            

                499
            

            

                
            

            

                
                                                                                returns.push(v368);

            

        

            

                500
            

            

                
            

            

                
                                                                            }

            

        

            

                501
            

            

                
            

            

                
                                                                        }

            

        

            

                502
            

            

                
            

            

                
                                                                    }

            

        

            

                503
            

            

                
            

            

                
                                                                }

            

        

            

                504
            

            

                
            

            

                
                                                            }

            

        

            

                505
            

            

                
            

            

                
                                                        }

            

        

            

                506
            

            

                
            

            

                
                                                    }

            

        

            

                507
            

            

                
            

            

                
                                                }

            

        

            

                508
            

            

                
            

            

                
                                            }

            

        

            

                509
            

            

                
            

            

                
                                        }

            

        

            

                510
            

            

                
            

            

                
                                        &Opcode::Isub => {

            

        

            

                511
            

            

                
            

            

                
                                            if v2.0 == v29.0 {

            

        

            

                512
            

            

                
            

            

                
                                                let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                513
            

            

                
            

            

                
                                                let mut v20 = v20;

            

        

            

                514
            

            

                
            

            

                
                                                while let Some(v21) = v20.next(ctx) {

            

        

            

                515
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                516
            

            

                
            

            

                
                                                        opcode: ref v24,

            

        

            

                517
            

            

                
            

            

                
                                                        imm: v25,

            

        

            

                518
            

            

                
            

            

                
                                                    } = &v21.1

            

        

            

                519
            

            

                
            

            

                
                                                    {

            

        

            

                520
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v24 {

            

        

            

                521
            

            

                
            

            

                
                                                            if v2.0 == v21.0 {

            

        

            

                522
            

            

                
            

            

                
                                                                let v72 = C::unpack_value_array_2(

            

        

            

                523
            

            

                
            

            

                
                                                                    ctx, v71,

            

        

            

                524
            

            

                
            

            

                
                                                                );

            

        

            

                525
            

            

                
            

            

                
                                                                let v82 =

            

        

            

                526
            

            

                
            

            

                
                                                                    C::inst_data_etor(ctx, v72.1);

            

        

            

                527
            

            

                
            

            

                
                                                                let mut v82 = v82;

            

        

            

                528
            

            

                
            

            

                
                                                                while let Some(v83) = v82.next(ctx)

            

        

            

                529
            

            

                
            

            

                
                                                                {

            

        

            

                530
            

            

                
            

            

                
                                                                    if let &InstructionData::UnaryImm {

            

        

            

                531
            

            

                
            

            

                
                                                                        opcode: ref v86,

            

        

            

                532
            

            

                
            

            

                
                                                                        imm: v87,

            

        

            

                533
            

            

                
            

            

                
                                                                    } = &v83.1 {

            

        

            

                534
            

            

                
            

            

                
                                                                        if let &Opcode::Iconst = v86 {

            

        

            

                535
            

            

                
            

            

                
                                                                            if v2.0 == v83.0 {

            

        

            

                536
            

            

                
            

            

                
                                                                                let v88 = C::u64_from_imm64(ctx, v87);

            

        

            

                537
            

            

                
            

            

                
                                                                                let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                538
            

            

                
            

            

                
                                                                                let v354 = C::u64_add(ctx, v88, v26);

            

        

            

                539
            

            

                
            

            

                
                                                                                let v355 = C::imm64_masked(ctx, v2.0, v354);

            

        

            

                540
            

            

                
            

            

                
                                                                                let v356 = constructor_iconst(ctx, v2.0, v355);

            

        

            

                541
            

            

                
            

            

                
                                                                                let v357 = constructor_isub(ctx, v2.0, v72.0, v356);

            

        

            

                542
            

            

                
            

            

                
                                                                                // Rule at src/opts/cprop.isle line 132.

            

        

            

                543
            

            

                
            

            

                
                                                                                returns.push(v357);

            

        

            

                544
            

            

                
            

            

                
                                                                            }

            

        

            

                545
            

            

                
            

            

                
                                                                        }

            

        

            

                546
            

            

                
            

            

                
                                                                    }

            

        

            

                547
            

            

                
            

            

                
                                                                }

            

        

            

                548
            

            

                
            

            

                
                                                                let v118 =

            

        

            

                549
            

            

                
            

            

                
                                                                    C::inst_data_etor(ctx, v72.0);

            

        

            

                550
            

            

                
            

            

                
                                                                let mut v118 = v118;

            

        

            

                551
            

            

                
            

            

                
                                                                while let Some(v119) =

            

        

            

                552
            

            

                
            

            

                
                                                                    v118.next(ctx)

            

        

            

                553
            

            

                
            

            

                
                                                                {

            

        

            

                554
            

            

                
            

            

                
                                                                    if let &InstructionData::UnaryImm {

            

        

            

                555
            

            

                
            

            

                
                                                                        opcode: ref v358,

            

        

            

                556
            

            

                
            

            

                
                                                                        imm: v359,

            

        

            

                557
            

            

                
            

            

                
                                                                    } = &v119.1 {

            

        

            

                558
            

            

                
            

            

                
                                                                        if let &Opcode::Iconst = v358 {

            

        

            

                559
            

            

                
            

            

                
                                                                            if v2.0 == v119.0 {

            

        

            

                560
            

            

                
            

            

                
                                                                                let v360 = C::u64_from_imm64(ctx, v359);

            

        

            

                561
            

            

                
            

            

                
                                                                                let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                562
            

            

                
            

            

                
                                                                                let v361 = C::u64_sub(ctx, v360, v26);

            

        

            

                563
            

            

                
            

            

                
                                                                                let v362 = C::imm64_masked(ctx, v2.0, v361);

            

        

            

                564
            

            

                
            

            

                
                                                                                let v363 = constructor_iconst(ctx, v2.0, v362);

            

        

            

                565
            

            

                
            

            

                
                                                                                let v364 = constructor_isub(ctx, v2.0, v363, v72.1);

            

        

            

                566
            

            

                
            

            

                
                                                                                // Rule at src/opts/cprop.isle line 136.

            

        

            

                567
            

            

                
            

            

                
                                                                                returns.push(v364);

            

        

            

                568
            

            

                
            

            

                
                                                                            }

            

        

            

                569
            

            

                
            

            

                
                                                                        }

            

        

            

                570
            

            

                
            

            

                
                                                                    }

            

        

            

                571
            

            

                
            

            

                
                                                                }

            

        

            

                572
            

            

                
            

            

                
                                                            }

            

        

            

                573
            

            

                
            

            

                
                                                        }

            

        

            

                574
            

            

                
            

            

                
                                                    }

            

        

            

                575
            

            

                
            

            

                
                                                }

            

        

            

                576
            

            

                
            

            

                
                                            }

            

        

            

                577
            

            

                
            

            

                
                                        }

            

        

            

                578
            

            

                
            

            

                
                                        _ => {}

            

        

            

                579
            

            

                
            

            

                
                                    }

            

        

            

                580
            

            

                
            

            

                
                                }

            

        

            

                581
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                582
            

            

                
            

            

                
                                    opcode: ref v32,

            

        

            

                583
            

            

                
            

            

                
                                    imm: v33,

            

        

            

                584
            

            

                
            

            

                
                                } => {

            

        

            

                585
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v32 {

            

        

            

                586
            

            

                
            

            

                
                                        if v2.0 == v29.0 {

            

        

            

                587
            

            

                
            

            

                
                                            let v34 = C::u64_from_imm64(ctx, v33);

            

        

            

                588
            

            

                
            

            

                
                                            if v34 == 0x0 {

            

        

            

                589
            

            

                
            

            

                
                                                let v36 = constructor_ineg(ctx, v2.0, v17.1);

            

        

            

                590
            

            

                
            

            

                
                                                // Rule at src/opts/algebraic.isle line 30.

            

        

            

                591
            

            

                
            

            

                
                                                returns.push(v36);

            

        

            

                592
            

            

                
            

            

                
                                            }

            

        

            

                593
            

            

                
            

            

                
                                            let v344 = constructor_isub(ctx, v2.0, v17.1, v17.0);

            

        

            

                594
            

            

                
            

            

                
                                            let v345 = constructor_ineg(ctx, v2.0, v344);

            

        

            

                595
            

            

                
            

            

                
                                            // Rule at src/opts/cprop.isle line 96.

            

        

            

                596
            

            

                
            

            

                
                                            returns.push(v345);

            

        

            

                597
            

            

                
            

            

                
                                        }

            

        

            

                598
            

            

                
            

            

                
                                        let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                599
            

            

                
            

            

                
                                        if let Some(v47) = v46 {

            

        

            

                600
            

            

                
            

            

                
                                            if v29.0 == v47 {

            

        

            

                601
            

            

                
            

            

                
                                                let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                602
            

            

                
            

            

                
                                                let mut v20 = v20;

            

        

            

                603
            

            

                
            

            

                
                                                while let Some(v21) = v20.next(ctx) {

            

        

            

                604
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                605
            

            

                
            

            

                
                                                        opcode: ref v24,

            

        

            

                606
            

            

                
            

            

                
                                                        imm: v25,

            

        

            

                607
            

            

                
            

            

                
                                                    } = &v21.1

            

        

            

                608
            

            

                
            

            

                
                                                    {

            

        

            

                609
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v24 {

            

        

            

                610
            

            

                
            

            

                
                                                            if v21.0 == v29.0 {

            

        

            

                611
            

            

                
            

            

                
                                                                let v34 =

            

        

            

                612
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v33);

            

        

            

                613
            

            

                
            

            

                
                                                                let v26 =

            

        

            

                614
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v25);

            

        

            

                615
            

            

                
            

            

                
                                                                let v283 =

            

        

            

                616
            

            

                
            

            

                
                                                                    C::u64_sub(ctx, v34, v26);

            

        

            

                617
            

            

                
            

            

                
                                                                let v284 =

            

        

            

                618
            

            

                
            

            

                
                                                                    C::imm64_masked(ctx, v47, v283);

            

        

            

                619
            

            

                
            

            

                
                                                                let v285 = constructor_iconst(

            

        

            

                620
            

            

                
            

            

                
                                                                    ctx, v47, v284,

            

        

            

                621
            

            

                
            

            

                
                                                                );

            

        

            

                622
            

            

                
            

            

                
                                                                let v286 = C::subsume(ctx, v285);

            

        

            

                623
            

            

                
            

            

                
                                                                // Rule at src/opts/cprop.isle line 9.

            

        

            

                624
            

            

                
            

            

                
                                                                returns.push(v286);

            

        

            

                625
            

            

                
            

            

                
                                                            }

            

        

            

                626
            

            

                
            

            

                
                                                        }

            

        

            

                627
            

            

                
            

            

                
                                                    }

            

        

            

                628
            

            

                
            

            

                
                                                }

            

        

            

                629
            

            

                
            

            

                
                                            }

            

        

            

                630
            

            

                
            

            

                
                                        }

            

        

            

                631
            

            

                
            

            

                
                                        let v138 = C::remat(ctx, arg0);

            

        

            

                632
            

            

                
            

            

                
                                        // Rule at src/opts/algebraic.isle line 300.

            

        

            

                633
            

            

                
            

            

                
                                        returns.push(v138);

            

        

            

                634
            

            

                
            

            

                
                                    }

            

        

            

                635
            

            

                
            

            

                
                                }

            

        

            

                636
            

            

                
            

            

                
                                _ => {}

            

        

            

                637
            

            

                
            

            

                
                            }

            

        

            

                638
            

            

                
            

            

                
                        }

            

        

            

                639
            

            

                
            

            

                
                        let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                640
            

            

                
            

            

                
                        let mut v20 = v20;

            

        

            

                641
            

            

                
            

            

                
                        while let Some(v21) = v20.next(ctx) {

            

        

            

                642
            

            

                
            

            

                
                            if let &InstructionData::UnaryImm {

            

        

            

                643
            

            

                
            

            

                
                                opcode: ref v24,

            

        

            

                644
            

            

                
            

            

                
                                imm: v25,

            

        

            

                645
            

            

                
            

            

                
                            } = &v21.1

            

        

            

                646
            

            

                
            

            

                
                            {

            

        

            

                647
            

            

                
            

            

                
                                if let &Opcode::Iconst = v24 {

            

        

            

                648
            

            

                
            

            

                
                                    let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                649
            

            

                
            

            

                
                                    if v26 == 0x0 {

            

        

            

                650
            

            

                
            

            

                
                                        if v2.0 == v21.0 {

            

        

            

                651
            

            

                
            

            

                
                                            let v27 = C::subsume(ctx, v17.0);

            

        

            

                652
            

            

                
            

            

                
                                            // Rule at src/opts/algebraic.isle line 25.

            

        

            

                653
            

            

                
            

            

                
                                            returns.push(v27);

            

        

            

                654
            

            

                
            

            

                
                                        }

            

        

            

                655
            

            

                
            

            

                
                                    }

            

        

            

                656
            

            

                
            

            

                
                                    let v138 = C::remat(ctx, arg0);

            

        

            

                657
            

            

                
            

            

                
                                    // Rule at src/opts/algebraic.isle line 302.

            

        

            

                658
            

            

                
            

            

                
                                    returns.push(v138);

            

        

            

                659
            

            

                
            

            

                
                                }

            

        

            

                660
            

            

                
            

            

                
                            }

            

        

            

                661
            

            

                
            

            

                
                        }

            

        

            

                662
            

            

                
            

            

                
                        if v17.0 == v17.1 {

            

        

            

                663
            

            

                
            

            

                
                            let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                664
            

            

                
            

            

                
                            if let Some(v47) = v46 {

            

        

            

                665
            

            

                
            

            

                
                                let v48 = C::ty_int(ctx, v47);

            

        

            

                666
            

            

                
            

            

                
                                if let Some(v49) = v48 {

            

        

            

                667
            

            

                
            

            

                
                                    let v51 = C::imm64(ctx, 0x0);

            

        

            

                668
            

            

                
            

            

                
                                    let v52 = constructor_iconst(ctx, v49, v51);

            

        

            

                669
            

            

                
            

            

                
                                    let v53 = C::subsume(ctx, v52);

            

        

            

                670
            

            

                
            

            

                
                                    // Rule at src/opts/algebraic.isle line 51.

            

        

            

                671
            

            

                
            

            

                
                                    returns.push(v53);

            

        

            

                672
            

            

                
            

            

                
                                }

            

        

            

                673
            

            

                
            

            

                
                            }

            

        

            

                674
            

            

                
            

            

                
                        }

            

        

            

                675
            

            

                
            

            

                
                    }

            

        

            

                676
            

            

                
            

            

                
                    &Opcode::Imul => {

            

        

            

                677
            

            

                
            

            

                
                        let v17 = C::unpack_value_array_2(ctx, v16);

            

        

            

                678
            

            

                
            

            

                
                        let v28 = C::inst_data_etor(ctx, v17.0);

            

        

            

                679
            

            

                
            

            

                
                        let mut v28 = v28;

            

        

            

                680
            

            

                
            

            

                
                        while let Some(v29) = v28.next(ctx) {

            

        

            

                681
            

            

                
            

            

                
                            match &v29.1 {

            

        

            

                682
            

            

                
            

            

                
                                &InstructionData::Binary {

            

        

            

                683
            

            

                
            

            

                
                                    opcode: ref v70,

            

        

            

                684
            

            

                
            

            

                
                                    args: ref v71,

            

        

            

                685
            

            

                
            

            

                
                                } => {

            

        

            

                686
            

            

                
            

            

                
                                    if let &Opcode::Imul = v70 {

            

        

            

                687
            

            

                
            

            

                
                                        if v2.0 == v29.0 {

            

        

            

                688
            

            

                
            

            

                
                                            let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                689
            

            

                
            

            

                
                                            let mut v20 = v20;

            

        

            

                690
            

            

                
            

            

                
                                            while let Some(v21) = v20.next(ctx) {

            

        

            

                691
            

            

                
            

            

                
                                                if let &InstructionData::UnaryImm {

            

        

            

                692
            

            

                
            

            

                
                                                    opcode: ref v24,

            

        

            

                693
            

            

                
            

            

                
                                                    imm: v25,

            

        

            

                694
            

            

                
            

            

                
                                                } = &v21.1

            

        

            

                695
            

            

                
            

            

                
                                                {

            

        

            

                696
            

            

                
            

            

                
                                                    if let &Opcode::Iconst = v24 {

            

        

            

                697
            

            

                
            

            

                
                                                        if v2.0 == v21.0 {

            

        

            

                698
            

            

                
            

            

                
                                                            let v72 =

            

        

            

                699
            

            

                
            

            

                
                                                                C::unpack_value_array_2(ctx, v71);

            

        

            

                700
            

            

                
            

            

                
                                                            let v82 = C::inst_data_etor(ctx, v72.1);

            

        

            

                701
            

            

                
            

            

                
                                                            let mut v82 = v82;

            

        

            

                702
            

            

                
            

            

                
                                                            while let Some(v83) = v82.next(ctx) {

            

        

            

                703
            

            

                
            

            

                
                                                                if let &InstructionData::UnaryImm {

            

        

            

                704
            

            

                
            

            

                
                                                                    opcode: ref v86,

            

        

            

                705
            

            

                
            

            

                
                                                                    imm: v87,

            

        

            

                706
            

            

                
            

            

                
                                                                } = &v83.1 {

            

        

            

                707
            

            

                
            

            

                
                                                                    if let &Opcode::Iconst = v86 {

            

        

            

                708
            

            

                
            

            

                
                                                                        if v2.0 == v83.0 {

            

        

            

                709
            

            

                
            

            

                
                                                                            let v374 = constructor_imul(ctx, v2.0, v72.1, v17.1);

            

        

            

                710
            

            

                
            

            

                
                                                                            let v375 = constructor_imul(ctx, v2.0, v72.0, v374);

            

        

            

                711
            

            

                
            

            

                
                                                                            // Rule at src/opts/cprop.isle line 153.

            

        

            

                712
            

            

                
            

            

                
                                                                            returns.push(v375);

            

        

            

                713
            

            

                
            

            

                
                                                                        }

            

        

            

                714
            

            

                
            

            

                
                                                                    }

            

        

            

                715
            

            

                
            

            

                
                                                                }

            

        

            

                716
            

            

                
            

            

                
                                                            }

            

        

            

                717
            

            

                
            

            

                
                                                        }

            

        

            

                718
            

            

                
            

            

                
                                                    }

            

        

            

                719
            

            

                
            

            

                
                                                }

            

        

            

                720
            

            

                
            

            

                
                                            }

            

        

            

                721
            

            

                
            

            

                
                                        }

            

        

            

                722
            

            

                
            

            

                
                                    }

            

        

            

                723
            

            

                
            

            

                
                                }

            

        

            

                724
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                725
            

            

                
            

            

                
                                    opcode: ref v38,

            

        

            

                726
            

            

                
            

            

                
                                    arg: v39,

            

        

            

                727
            

            

                
            

            

                
                                } => {

            

        

            

                728
            

            

                
            

            

                
                                    if let &Opcode::Ineg = v38 {

            

        

            

                729
            

            

                
            

            

                
                                        if v2.0 == v29.0 {

            

        

            

                730
            

            

                
            

            

                
                                            let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                731
            

            

                
            

            

                
                                            let mut v20 = v20;

            

        

            

                732
            

            

                
            

            

                
                                            while let Some(v21) = v20.next(ctx) {

            

        

            

                733
            

            

                
            

            

                
                                                if let &InstructionData::Unary {

            

        

            

                734
            

            

                
            

            

                
                                                    opcode: ref v40,

            

        

            

                735
            

            

                
            

            

                
                                                    arg: v41,

            

        

            

                736
            

            

                
            

            

                
                                                } = &v21.1

            

        

            

                737
            

            

                
            

            

                
                                                {

            

        

            

                738
            

            

                
            

            

                
                                                    if let &Opcode::Ineg = v40 {

            

        

            

                739
            

            

                
            

            

                
                                                        if v2.0 == v21.0 {

            

        

            

                740
            

            

                
            

            

                
                                                            let v42 = constructor_imul(

            

        

            

                741
            

            

                
            

            

                
                                                                ctx, v2.0, v39, v41,

            

        

            

                742
            

            

                
            

            

                
                                                            );

            

        

            

                743
            

            

                
            

            

                
                                                            let v43 = C::subsume(ctx, v42);

            

        

            

                744
            

            

                
            

            

                
                                                            // Rule at src/opts/algebraic.isle line 39.

            

        

            

                745
            

            

                
            

            

                
                                                            returns.push(v43);

            

        

            

                746
            

            

                
            

            

                
                                                        }

            

        

            

                747
            

            

                
            

            

                
                                                    }

            

        

            

                748
            

            

                
            

            

                
                                                }

            

        

            

                749
            

            

                
            

            

                
                                            }

            

        

            

                750
            

            

                
            

            

                
                                        }

            

        

            

                751
            

            

                
            

            

                
                                    }

            

        

            

                752
            

            

                
            

            

                
                                }

            

        

            

                753
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                754
            

            

                
            

            

                
                                    opcode: ref v32,

            

        

            

                755
            

            

                
            

            

                
                                    imm: v33,

            

        

            

                756
            

            

                
            

            

                
                                } => {

            

        

            

                757
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v32 {

            

        

            

                758
            

            

                
            

            

                
                                        if v2.0 == v29.0 {

            

        

            

                759
            

            

                
            

            

                
                                            let v34 = C::u64_from_imm64(ctx, v33);

            

        

            

                760
            

            

                
            

            

                
                                            match v34 {

            

        

            

                761
            

            

                
            

            

                
                                                0x0 => {

            

        

            

                762
            

            

                
            

            

                
                                                    let v27 = C::subsume(ctx, v17.0);

            

        

            

                763
            

            

                
            

            

                
                                                    // Rule at src/opts/algebraic.isle line 68.

            

        

            

                764
            

            

                
            

            

                
                                                    returns.push(v27);

            

        

            

                765
            

            

                
            

            

                
                                                }

            

        

            

                766
            

            

                
            

            

                
                                                0x1 => {

            

        

            

                767
            

            

                
            

            

                
                                                    let v35 = C::subsume(ctx, v17.1);

            

        

            

                768
            

            

                
            

            

                
                                                    // Rule at src/opts/algebraic.isle line 58.

            

        

            

                769
            

            

                
            

            

                
                                                    returns.push(v35);

            

        

            

                770
            

            

                
            

            

                
                                                }

            

        

            

                771
            

            

                
            

            

                
                                                _ => {}

            

        

            

                772
            

            

                
            

            

                
                                            }

            

        

            

                773
            

            

                
            

            

                
                                            let v56 = C::i64_sextend_imm64(ctx, v2.0, v33);

            

        

            

                774
            

            

                
            

            

                
                                            if v56 == -0x1 {

            

        

            

                775
            

            

                
            

            

                
                                                let v36 = constructor_ineg(ctx, v2.0, v17.1);

            

        

            

                776
            

            

                
            

            

                
                                                // Rule at src/opts/algebraic.isle line 77.

            

        

            

                777
            

            

                
            

            

                
                                                returns.push(v36);

            

        

            

                778
            

            

                
            

            

                
                                            }

            

        

            

                779
            

            

                
            

            

                
                                            let v346 = constructor_imul(ctx, v2.0, v17.1, v17.0);

            

        

            

                780
            

            

                
            

            

                
                                            // Rule at src/opts/cprop.isle line 99.

            

        

            

                781
            

            

                
            

            

                
                                            returns.push(v346);

            

        

            

                782
            

            

                
            

            

                
                                        }

            

        

            

                783
            

            

                
            

            

                
                                        let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                784
            

            

                
            

            

                
                                        if let Some(v47) = v46 {

            

        

            

                785
            

            

                
            

            

                
                                            if v29.0 == v47 {

            

        

            

                786
            

            

                
            

            

                
                                                let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                787
            

            

                
            

            

                
                                                let mut v20 = v20;

            

        

            

                788
            

            

                
            

            

                
                                                while let Some(v21) = v20.next(ctx) {

            

        

            

                789
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                790
            

            

                
            

            

                
                                                        opcode: ref v24,

            

        

            

                791
            

            

                
            

            

                
                                                        imm: v25,

            

        

            

                792
            

            

                
            

            

                
                                                    } = &v21.1

            

        

            

                793
            

            

                
            

            

                
                                                    {

            

        

            

                794
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v24 {

            

        

            

                795
            

            

                
            

            

                
                                                            if v21.0 == v29.0 {

            

        

            

                796
            

            

                
            

            

                
                                                                let v34 =

            

        

            

                797
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v33);

            

        

            

                798
            

            

                
            

            

                
                                                                let v26 =

            

        

            

                799
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v25);

            

        

            

                800
            

            

                
            

            

                
                                                                let v287 =

            

        

            

                801
            

            

                
            

            

                
                                                                    C::u64_mul(ctx, v34, v26);

            

        

            

                802
            

            

                
            

            

                
                                                                let v288 =

            

        

            

                803
            

            

                
            

            

                
                                                                    C::imm64_masked(ctx, v47, v287);

            

        

            

                804
            

            

                
            

            

                
                                                                let v289 = constructor_iconst(

            

        

            

                805
            

            

                
            

            

                
                                                                    ctx, v47, v288,

            

        

            

                806
            

            

                
            

            

                
                                                                );

            

        

            

                807
            

            

                
            

            

                
                                                                let v290 = C::subsume(ctx, v289);

            

        

            

                808
            

            

                
            

            

                
                                                                // Rule at src/opts/cprop.isle line 15.

            

        

            

                809
            

            

                
            

            

                
                                                                returns.push(v290);

            

        

            

                810
            

            

                
            

            

                
                                                            }

            

        

            

                811
            

            

                
            

            

                
                                                        }

            

        

            

                812
            

            

                
            

            

                
                                                    }

            

        

            

                813
            

            

                
            

            

                
                                                }

            

        

            

                814
            

            

                
            

            

                
                                            }

            

        

            

                815
            

            

                
            

            

                
                                        }

            

        

            

                816
            

            

                
            

            

                
                                        let v97 = C::simm32(ctx, v33);

            

        

            

                817
            

            

                
            

            

                
                                        if let Some(v98) = v97 {

            

        

            

                818
            

            

                
            

            

                
                                            if v98 == 0x2 {

            

        

            

                819
            

            

                
            

            

                
                                                let v99 = constructor_iadd(ctx, v2.0, v17.1, v17.1);

            

        

            

                820
            

            

                
            

            

                
                                                // Rule at src/opts/algebraic.isle line 204.

            

        

            

                821
            

            

                
            

            

                
                                                returns.push(v99);

            

        

            

                822
            

            

                
            

            

                
                                            }

            

        

            

                823
            

            

                
            

            

                
                                        }

            

        

            

                824
            

            

                
            

            

                
                                        let v105 = C::imm64_power_of_two(ctx, v33);

            

        

            

                825
            

            

                
            

            

                
                                        if let Some(v106) = v105 {

            

        

            

                826
            

            

                
            

            

                
                                            let v107 = C::imm64(ctx, v106);

            

        

            

                827
            

            

                
            

            

                
                                            let v108 = constructor_iconst(ctx, v2.0, v107);

            

        

            

                828
            

            

                
            

            

                
                                            let v109 = constructor_ishl(ctx, v2.0, v17.1, v108);

            

        

            

                829
            

            

                
            

            

                
                                            // Rule at src/opts/algebraic.isle line 213.

            

        

            

                830
            

            

                
            

            

                
                                            returns.push(v109);

            

        

            

                831
            

            

                
            

            

                
                                        }

            

        

            

                832
            

            

                
            

            

                
                                    }

            

        

            

                833
            

            

                
            

            

                
                                }

            

        

            

                834
            

            

                
            

            

                
                                _ => {}

            

        

            

                835
            

            

                
            

            

                
                            }

            

        

            

                836
            

            

                
            

            

                
                        }

            

        

            

                837
            

            

                
            

            

                
                        let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                838
            

            

                
            

            

                
                        let mut v20 = v20;

            

        

            

                839
            

            

                
            

            

                
                        while let Some(v21) = v20.next(ctx) {

            

        

            

                840
            

            

                
            

            

                
                            if let &InstructionData::UnaryImm {

            

        

            

                841
            

            

                
            

            

                
                                opcode: ref v24,

            

        

            

                842
            

            

                
            

            

                
                                imm: v25,

            

        

            

                843
            

            

                
            

            

                
                            } = &v21.1

            

        

            

                844
            

            

                
            

            

                
                            {

            

        

            

                845
            

            

                
            

            

                
                                if let &Opcode::Iconst = v24 {

            

        

            

                846
            

            

                
            

            

                
                                    if v2.0 == v21.0 {

            

        

            

                847
            

            

                
            

            

                
                                        let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                848
            

            

                
            

            

                
                                        match v26 {

            

        

            

                849
            

            

                
            

            

                
                                            0x0 => {

            

        

            

                850
            

            

                
            

            

                
                                                let v35 = C::subsume(ctx, v17.1);

            

        

            

                851
            

            

                
            

            

                
                                                // Rule at src/opts/algebraic.isle line 64.

            

        

            

                852
            

            

                
            

            

                
                                                returns.push(v35);

            

        

            

                853
            

            

                
            

            

                
                                            }

            

        

            

                854
            

            

                
            

            

                
                                            0x1 => {

            

        

            

                855
            

            

                
            

            

                
                                                let v27 = C::subsume(ctx, v17.0);

            

        

            

                856
            

            

                
            

            

                
                                                // Rule at src/opts/algebraic.isle line 54.

            

        

            

                857
            

            

                
            

            

                
                                                returns.push(v27);

            

        

            

                858
            

            

                
            

            

                
                                            }

            

        

            

                859
            

            

                
            

            

                
                                            _ => {}

            

        

            

                860
            

            

                
            

            

                
                                        }

            

        

            

                861
            

            

                
            

            

                
                                        let v54 = C::i64_sextend_imm64(ctx, v2.0, v25);

            

        

            

                862
            

            

                
            

            

                
                                        if v54 == -0x1 {

            

        

            

                863
            

            

                
            

            

                
                                            let v55 = constructor_ineg(ctx, v2.0, v17.0);

            

        

            

                864
            

            

                
            

            

                
                                            // Rule at src/opts/algebraic.isle line 74.

            

        

            

                865
            

            

                
            

            

                
                                            returns.push(v55);

            

        

            

                866
            

            

                
            

            

                
                                        }

            

        

            

                867
            

            

                
            

            

                
                                    }

            

        

            

                868
            

            

                
            

            

                
                                    let v94 = C::simm32(ctx, v25);

            

        

            

                869
            

            

                
            

            

                
                                    if let Some(v95) = v94 {

            

        

            

                870
            

            

                
            

            

                
                                        if v95 == 0x2 {

            

        

            

                871
            

            

                
            

            

                
                                            let v96 = constructor_iadd(ctx, v2.0, v17.0, v17.0);

            

        

            

                872
            

            

                
            

            

                
                                            // Rule at src/opts/algebraic.isle line 202.

            

        

            

                873
            

            

                
            

            

                
                                            returns.push(v96);

            

        

            

                874
            

            

                
            

            

                
                                        }

            

        

            

                875
            

            

                
            

            

                
                                    }

            

        

            

                876
            

            

                
            

            

                
                                    let v100 = C::imm64_power_of_two(ctx, v25);

            

        

            

                877
            

            

                
            

            

                
                                    if let Some(v101) = v100 {

            

        

            

                878
            

            

                
            

            

                
                                        let v102 = C::imm64(ctx, v101);

            

        

            

                879
            

            

                
            

            

                
                                        let v103 = constructor_iconst(ctx, v2.0, v102);

            

        

            

                880
            

            

                
            

            

                
                                        let v104 = constructor_ishl(ctx, v2.0, v17.0, v103);

            

        

            

                881
            

            

                
            

            

                
                                        // Rule at src/opts/algebraic.isle line 211.

            

        

            

                882
            

            

                
            

            

                
                                        returns.push(v104);

            

        

            

                883
            

            

                
            

            

                
                                    }

            

        

            

                884
            

            

                
            

            

                
                                }

            

        

            

                885
            

            

                
            

            

                
                            }

            

        

            

                886
            

            

                
            

            

                
                        }

            

        

            

                887
            

            

                
            

            

                
                    }

            

        

            

                888
            

            

                
            

            

                
                    &Opcode::Udiv => {

            

        

            

                889
            

            

                
            

            

                
                        let v17 = C::unpack_value_array_2(ctx, v16);

            

        

            

                890
            

            

                
            

            

                
                        let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                891
            

            

                
            

            

                
                        let mut v20 = v20;

            

        

            

                892
            

            

                
            

            

                
                        while let Some(v21) = v20.next(ctx) {

            

        

            

                893
            

            

                
            

            

                
                            if let &InstructionData::UnaryImm {

            

        

            

                894
            

            

                
            

            

                
                                opcode: ref v24,

            

        

            

                895
            

            

                
            

            

                
                                imm: v25,

            

        

            

                896
            

            

                
            

            

                
                            } = &v21.1

            

        

            

                897
            

            

                
            

            

                
                            {

            

        

            

                898
            

            

                
            

            

                
                                if let &Opcode::Iconst = v24 {

            

        

            

                899
            

            

                
            

            

                
                                    let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                900
            

            

                
            

            

                
                                    if v26 == 0x1 {

            

        

            

                901
            

            

                
            

            

                
                                        if v2.0 == v21.0 {

            

        

            

                902
            

            

                
            

            

                
                                            let v27 = C::subsume(ctx, v17.0);

            

        

            

                903
            

            

                
            

            

                
                                            // Rule at src/opts/algebraic.isle line 86.

            

        

            

                904
            

            

                
            

            

                
                                            returns.push(v27);

            

        

            

                905
            

            

                
            

            

                
                                        }

            

        

            

                906
            

            

                
            

            

                
                                    }

            

        

            

                907
            

            

                
            

            

                
                                    let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                908
            

            

                
            

            

                
                                    if let Some(v47) = v46 {

            

        

            

                909
            

            

                
            

            

                
                                        if v21.0 == v47 {

            

        

            

                910
            

            

                
            

            

                
                                            let v28 = C::inst_data_etor(ctx, v17.0);

            

        

            

                911
            

            

                
            

            

                
                                            let mut v28 = v28;

            

        

            

                912
            

            

                
            

            

                
                                            while let Some(v29) = v28.next(ctx) {

            

        

            

                913
            

            

                
            

            

                
                                                if let &InstructionData::UnaryImm {

            

        

            

                914
            

            

                
            

            

                
                                                    opcode: ref v32,

            

        

            

                915
            

            

                
            

            

                
                                                    imm: v33,

            

        

            

                916
            

            

                
            

            

                
                                                } = &v29.1

            

        

            

                917
            

            

                
            

            

                
                                                {

            

        

            

                918
            

            

                
            

            

                
                                                    if let &Opcode::Iconst = v32 {

            

        

            

                919
            

            

                
            

            

                
                                                        let v34 = C::u64_from_imm64(ctx, v33);

            

        

            

                920
            

            

                
            

            

                
                                                        let v296 = C::u64_udiv(ctx, v34, v26);

            

        

            

                921
            

            

                
            

            

                
                                                        if let Some(v297) = v296 {

            

        

            

                922
            

            

                
            

            

                
                                                            if v21.0 == v29.0 {

            

        

            

                923
            

            

                
            

            

                
                                                                let v298 =

            

        

            

                924
            

            

                
            

            

                
                                                                    C::imm64_masked(ctx, v47, v297);

            

        

            

                925
            

            

                
            

            

                
                                                                let v299 = constructor_iconst(

            

        

            

                926
            

            

                
            

            

                
                                                                    ctx, v47, v298,

            

        

            

                927
            

            

                
            

            

                
                                                                );

            

        

            

                928
            

            

                
            

            

                
                                                                let v300 = C::subsume(ctx, v299);

            

        

            

                929
            

            

                
            

            

                
                                                                // Rule at src/opts/cprop.isle line 28.

            

        

            

                930
            

            

                
            

            

                
                                                                returns.push(v300);

            

        

            

                931
            

            

                
            

            

                
                                                            }

            

        

            

                932
            

            

                
            

            

                
                                                        }

            

        

            

                933
            

            

                
            

            

                
                                                    }

            

        

            

                934
            

            

                
            

            

                
                                                }

            

        

            

                935
            

            

                
            

            

                
                                            }

            

        

            

                936
            

            

                
            

            

                
                                        }

            

        

            

                937
            

            

                
            

            

                
                                    }

            

        

            

                938
            

            

                
            

            

                
                                }

            

        

            

                939
            

            

                
            

            

                
                            }

            

        

            

                940
            

            

                
            

            

                
                        }

            

        

            

                941
            

            

                
            

            

                
                    }

            

        

            

                942
            

            

                
            

            

                
                    &Opcode::Sdiv => {

            

        

            

                943
            

            

                
            

            

                
                        let v17 = C::unpack_value_array_2(ctx, v16);

            

        

            

                944
            

            

                
            

            

                
                        let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                945
            

            

                
            

            

                
                        let mut v20 = v20;

            

        

            

                946
            

            

                
            

            

                
                        while let Some(v21) = v20.next(ctx) {

            

        

            

                947
            

            

                
            

            

                
                            if let &InstructionData::UnaryImm {

            

        

            

                948
            

            

                
            

            

                
                                opcode: ref v24,

            

        

            

                949
            

            

                
            

            

                
                                imm: v25,

            

        

            

                950
            

            

                
            

            

                
                            } = &v21.1

            

        

            

                951
            

            

                
            

            

                
                            {

            

        

            

                952
            

            

                
            

            

                
                                if let &Opcode::Iconst = v24 {

            

        

            

                953
            

            

                
            

            

                
                                    let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                954
            

            

                
            

            

                
                                    if v26 == 0x1 {

            

        

            

                955
            

            

                
            

            

                
                                        if v2.0 == v21.0 {

            

        

            

                956
            

            

                
            

            

                
                                            let v27 = C::subsume(ctx, v17.0);

            

        

            

                957
            

            

                
            

            

                
                                            // Rule at src/opts/algebraic.isle line 82.

            

        

            

                958
            

            

                
            

            

                
                                            returns.push(v27);

            

        

            

                959
            

            

                
            

            

                
                                        }

            

        

            

                960
            

            

                
            

            

                
                                    }

            

        

            

                961
            

            

                
            

            

                
                                    let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                962
            

            

                
            

            

                
                                    if let Some(v47) = v46 {

            

        

            

                963
            

            

                
            

            

                
                                        if v21.0 == v47 {

            

        

            

                964
            

            

                
            

            

                
                                            let v28 = C::inst_data_etor(ctx, v17.0);

            

        

            

                965
            

            

                
            

            

                
                                            let mut v28 = v28;

            

        

            

                966
            

            

                
            

            

                
                                            while let Some(v29) = v28.next(ctx) {

            

        

            

                967
            

            

                
            

            

                
                                                if let &InstructionData::UnaryImm {

            

        

            

                968
            

            

                
            

            

                
                                                    opcode: ref v32,

            

        

            

                969
            

            

                
            

            

                
                                                    imm: v33,

            

        

            

                970
            

            

                
            

            

                
                                                } = &v29.1

            

        

            

                971
            

            

                
            

            

                
                                                {

            

        

            

                972
            

            

                
            

            

                
                                                    if let &Opcode::Iconst = v32 {

            

        

            

                973
            

            

                
            

            

                
                                                        let v34 = C::u64_from_imm64(ctx, v33);

            

        

            

                974
            

            

                
            

            

                
                                                        let v291 = C::u64_sdiv(ctx, v34, v26);

            

        

            

                975
            

            

                
            

            

                
                                                        if let Some(v292) = v291 {

            

        

            

                976
            

            

                
            

            

                
                                                            if v21.0 == v29.0 {

            

        

            

                977
            

            

                
            

            

                
                                                                let v293 =

            

        

            

                978
            

            

                
            

            

                
                                                                    C::imm64_masked(ctx, v47, v292);

            

        

            

                979
            

            

                
            

            

                
                                                                let v294 = constructor_iconst(

            

        

            

                980
            

            

                
            

            

                
                                                                    ctx, v47, v293,

            

        

            

                981
            

            

                
            

            

                
                                                                );

            

        

            

                982
            

            

                
            

            

                
                                                                let v295 = C::subsume(ctx, v294);

            

        

            

                983
            

            

                
            

            

                
                                                                // Rule at src/opts/cprop.isle line 21.

            

        

            

                984
            

            

                
            

            

                
                                                                returns.push(v295);

            

        

            

                985
            

            

                
            

            

                
                                                            }

            

        

            

                986
            

            

                
            

            

                
                                                        }

            

        

            

                987
            

            

                
            

            

                
                                                    }

            

        

            

                988
            

            

                
            

            

                
                                                }

            

        

            

                989
            

            

                
            

            

                
                                            }

            

        

            

                990
            

            

                
            

            

                
                                        }

            

        

            

                991
            

            

                
            

            

                
                                    }

            

        

            

                992
            

            

                
            

            

                
                                }

            

        

            

                993
            

            

                
            

            

                
                            }

            

        

            

                994
            

            

                
            

            

                
                        }

            

        

            

                995
            

            

                
            

            

                
                    }

            

        

            

                996
            

            

                
            

            

                
                    &Opcode::Band => {

            

        

            

                997
            

            

                
            

            

                
                        let v17 = C::unpack_value_array_2(ctx, v16);

            

        

            

                998
            

            

                
            

            

                
                        let v28 = C::inst_data_etor(ctx, v17.0);

            

        

            

                999
            

            

                
            

            

                
                        let mut v28 = v28;

            

        

            

                1000
            

            

                
            

            

                
                        while let Some(v29) = v28.next(ctx) {

            

        

            

                1001
            

            

                
            

            

                
                            match &v29.1 {

            

        

            

                1002
            

            

                
            

            

                
                                &InstructionData::Binary {

            

        

            

                1003
            

            

                
            

            

                
                                    opcode: ref v70,

            

        

            

                1004
            

            

                
            

            

                
                                    args: ref v71,

            

        

            

                1005
            

            

                
            

            

                
                                } => {

            

        

            

                1006
            

            

                
            

            

                
                                    if let &Opcode::Band = v70 {

            

        

            

                1007
            

            

                
            

            

                
                                        if v2.0 == v29.0 {

            

        

            

                1008
            

            

                
            

            

                
                                            let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                1009
            

            

                
            

            

                
                                            let mut v20 = v20;

            

        

            

                1010
            

            

                
            

            

                
                                            while let Some(v21) = v20.next(ctx) {

            

        

            

                1011
            

            

                
            

            

                
                                                if let &InstructionData::UnaryImm {

            

        

            

                1012
            

            

                
            

            

                
                                                    opcode: ref v24,

            

        

            

                1013
            

            

                
            

            

                
                                                    imm: v25,

            

        

            

                1014
            

            

                
            

            

                
                                                } = &v21.1

            

        

            

                1015
            

            

                
            

            

                
                                                {

            

        

            

                1016
            

            

                
            

            

                
                                                    if let &Opcode::Iconst = v24 {

            

        

            

                1017
            

            

                
            

            

                
                                                        if v2.0 == v21.0 {

            

        

            

                1018
            

            

                
            

            

                
                                                            let v72 =

            

        

            

                1019
            

            

                
            

            

                
                                                                C::unpack_value_array_2(ctx, v71);

            

        

            

                1020
            

            

                
            

            

                
                                                            let v82 = C::inst_data_etor(ctx, v72.1);

            

        

            

                1021
            

            

                
            

            

                
                                                            let mut v82 = v82;

            

        

            

                1022
            

            

                
            

            

                
                                                            while let Some(v83) = v82.next(ctx) {

            

        

            

                1023
            

            

                
            

            

                
                                                                if let &InstructionData::UnaryImm {

            

        

            

                1024
            

            

                
            

            

                
                                                                    opcode: ref v86,

            

        

            

                1025
            

            

                
            

            

                
                                                                    imm: v87,

            

        

            

                1026
            

            

                
            

            

                
                                                                } = &v83.1 {

            

        

            

                1027
            

            

                
            

            

                
                                                                    if let &Opcode::Iconst = v86 {

            

        

            

                1028
            

            

                
            

            

                
                                                                        if v2.0 == v83.0 {

            

        

            

                1029
            

            

                
            

            

                
                                                                            let v378 = constructor_band(ctx, v2.0, v72.1, v17.1);

            

        

            

                1030
            

            

                
            

            

                
                                                                            let v379 = constructor_band(ctx, v2.0, v72.0, v378);

            

        

            

                1031
            

            

                
            

            

                
                                                                            // Rule at src/opts/cprop.isle line 159.

            

        

            

                1032
            

            

                
            

            

                
                                                                            returns.push(v379);

            

        

            

                1033
            

            

                
            

            

                
                                                                        }

            

        

            

                1034
            

            

                
            

            

                
                                                                    }

            

        

            

                1035
            

            

                
            

            

                
                                                                }

            

        

            

                1036
            

            

                
            

            

                
                                                            }

            

        

            

                1037
            

            

                
            

            

                
                                                        }

            

        

            

                1038
            

            

                
            

            

                
                                                    }

            

        

            

                1039
            

            

                
            

            

                
                                                }

            

        

            

                1040
            

            

                
            

            

                
                                            }

            

        

            

                1041
            

            

                
            

            

                
                                        }

            

        

            

                1042
            

            

                
            

            

                
                                    }

            

        

            

                1043
            

            

                
            

            

                
                                }

            

        

            

                1044
            

            

                
            

            

                
                                &InstructionData::IntCompare {

            

        

            

                1045
            

            

                
            

            

                
                                    opcode: ref v240,

            

        

            

                1046
            

            

                
            

            

                
                                    args: ref v241,

            

        

            

                1047
            

            

                
            

            

                
                                    cond: ref v242,

            

        

            

                1048
            

            

                
            

            

                
                                } => {

            

        

            

                1049
            

            

                
            

            

                
                                    if let &Opcode::Icmp = v240 {

            

        

            

                1050
            

            

                
            

            

                
                                        let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                1051
            

            

                
            

            

                
                                        let mut v20 = v20;

            

        

            

                1052
            

            

                
            

            

                
                                        while let Some(v21) = v20.next(ctx) {

            

        

            

                1053
            

            

                
            

            

                
                                            match &v21.1 {

            

        

            

                1054
            

            

                
            

            

                
                                                &InstructionData::IntCompare {

            

        

            

                1055
            

            

                
            

            

                
                                                    opcode: ref v265,

            

        

            

                1056
            

            

                
            

            

                
                                                    args: ref v266,

            

        

            

                1057
            

            

                
            

            

                
                                                    cond: ref v267,

            

        

            

                1058
            

            

                
            

            

                
                                                } => {

            

        

            

                1059
            

            

                
            

            

                
                                                    if let &Opcode::Icmp = v265 {

            

        

            

                1060
            

            

                
            

            

                
                                                        let v271 = constructor_intcc_comparable(

            

        

            

                1061
            

            

                
            

            

                
                                                            ctx, v242, v267,

            

        

            

                1062
            

            

                
            

            

                
                                                        );

            

        

            

                1063
            

            

                
            

            

                
                                                        if let Some(v272) = v271 {

            

        

            

                1064
            

            

                
            

            

                
                                                            if v2.0 == v21.0 {

            

        

            

                1065
            

            

                
            

            

                
                                                                if v2.0 == v29.0 {

            

        

            

                1066
            

            

                
            

            

                
                                                                    let v243 =

            

        

            

                1067
            

            

                
            

            

                
                                                                        C::unpack_value_array_2(

            

        

            

                1068
            

            

                
            

            

                
                                                                            ctx, v241,

            

        

            

                1069
            

            

                
            

            

                
                                                                        );

            

        

            

                1070
            

            

                
            

            

                
                                                                    let v268 =

            

        

            

                1071
            

            

                
            

            

                
                                                                        C::unpack_value_array_2(

            

        

            

                1072
            

            

                
            

            

                
                                                                            ctx, v266,

            

        

            

                1073
            

            

                
            

            

                
                                                                        );

            

        

            

                1074
            

            

                
            

            

                
                                                                    if v243.0 == v268.0 {

            

        

            

                1075
            

            

                
            

            

                
                                                                        if v243.1 == v268.1 {

            

        

            

                1076
            

            

                
            

            

                
                                                                            let v273 = constructor_decompose_intcc(ctx, v242);

            

        

            

                1077
            

            

                
            

            

                
                                                                            let v274 = constructor_decompose_intcc(ctx, v267);

            

        

            

                1078
            

            

                
            

            

                
                                                                            let v275 = C::u64_and(

            

        

            

                1079
            

            

                
            

            

                
                                                                                ctx, v273, v274,

            

        

            

                1080
            

            

                
            

            

                
                                                                            );

            

        

            

                1081
            

            

                
            

            

                
                                                                            let v276 = constructor_compose_icmp(ctx, v2.0, v275, v272, v243.0, v243.1);

            

        

            

                1082
            

            

                
            

            

                
                                                                            // Rule at src/opts/icmp.isle line 128.

            

        

            

                1083
            

            

                
            

            

                
                                                                            returns.push(v276);

            

        

            

                1084
            

            

                
            

            

                
                                                                        }

            

        

            

                1085
            

            

                
            

            

                
                                                                    }

            

        

            

                1086
            

            

                
            

            

                
                                                                }

            

        

            

                1087
            

            

                
            

            

                
                                                            }

            

        

            

                1088
            

            

                
            

            

                
                                                        }

            

        

            

                1089
            

            

                
            

            

                
                                                    }

            

        

            

                1090
            

            

                
            

            

                
                                                }

            

        

            

                1091
            

            

                
            

            

                
                                                &InstructionData::UnaryImm {

            

        

            

                1092
            

            

                
            

            

                
                                                    opcode: ref v24,

            

        

            

                1093
            

            

                
            

            

                
                                                    imm: v25,

            

        

            

                1094
            

            

                
            

            

                
                                                } => {

            

        

            

                1095
            

            

                
            

            

                
                                                    if let &Opcode::Iconst = v24 {

            

        

            

                1096
            

            

                
            

            

                
                                                        let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                1097
            

            

                
            

            

                
                                                        if v26 == 0x1 {

            

        

            

                1098
            

            

                
            

            

                
                                                            let v238 = C::ty_int(ctx, v2.0);

            

        

            

                1099
            

            

                
            

            

                
                                                            if let Some(v239) = v238 {

            

        

            

                1100
            

            

                
            

            

                
                                                                // Rule at src/opts/icmp.isle line 39.

            

        

            

                1101
            

            

                
            

            

                
                                                                returns.push(v17.0);

            

        

            

                1102
            

            

                
            

            

                
                                                            }

            

        

            

                1103
            

            

                
            

            

                
                                                        }

            

        

            

                1104
            

            

                
            

            

                
                                                    }

            

        

            

                1105
            

            

                
            

            

                
                                                }

            

        

            

                1106
            

            

                
            

            

                
                                                _ => {}

            

        

            

                1107
            

            

                
            

            

                
                                            }

            

        

            

                1108
            

            

                
            

            

                
                                        }

            

        

            

                1109
            

            

                
            

            

                
                                    }

            

        

            

                1110
            

            

                
            

            

                
                                }

            

        

            

                1111
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                1112
            

            

                
            

            

                
                                    opcode: ref v38,

            

        

            

                1113
            

            

                
            

            

                
                                    arg: v39,

            

        

            

                1114
            

            

                
            

            

                
                                } => {

            

        

            

                1115
            

            

                
            

            

                
                                    match v38 {

            

        

            

                1116
            

            

                
            

            

                
                                        &Opcode::Bnot => {

            

        

            

                1117
            

            

                
            

            

                
                                            let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                1118
            

            

                
            

            

                
                                            if let Some(v47) = v46 {

            

        

            

                1119
            

            

                
            

            

                
                                                let v48 = C::ty_int(ctx, v47);

            

        

            

                1120
            

            

                
            

            

                
                                                if let Some(v49) = v48 {

            

        

            

                1121
            

            

                
            

            

                
                                                    if v17.1 == v39 {

            

        

            

                1122
            

            

                
            

            

                
                                                        if v29.0 == v49 {

            

        

            

                1123
            

            

                
            

            

                
                                                            let v51 = C::imm64(ctx, 0x0);

            

        

            

                1124
            

            

                
            

            

                
                                                            let v52 =

            

        

            

                1125
            

            

                
            

            

                
                                                                constructor_iconst(ctx, v49, v51);

            

        

            

                1126
            

            

                
            

            

                
                                                            let v53 = C::subsume(ctx, v52);

            

        

            

                1127
            

            

                
            

            

                
                                                            // Rule at src/opts/algebraic.isle line 160.

            

        

            

                1128
            

            

                
            

            

                
                                                            returns.push(v53);

            

        

            

                1129
            

            

                
            

            

                
                                                        }

            

        

            

                1130
            

            

                
            

            

                
                                                    }

            

        

            

                1131
            

            

                
            

            

                
                                                }

            

        

            

                1132
            

            

                
            

            

                
                                            }

            

        

            

                1133
            

            

                
            

            

                
                                        }

            

        

            

                1134
            

            

                
            

            

                
                                        &Opcode::Uextend => {

            

        

            

                1135
            

            

                
            

            

                
                                            let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                1136
            

            

                
            

            

                
                                            let mut v20 = v20;

            

        

            

                1137
            

            

                
            

            

                
                                            while let Some(v21) = v20.next(ctx) {

            

        

            

                1138
            

            

                
            

            

                
                                                if let &InstructionData::UnaryImm {

            

        

            

                1139
            

            

                
            

            

                
                                                    opcode: ref v24,

            

        

            

                1140
            

            

                
            

            

                
                                                    imm: v25,

            

        

            

                1141
            

            

                
            

            

                
                                                } = &v21.1

            

        

            

                1142
            

            

                
            

            

                
                                                {

            

        

            

                1143
            

            

                
            

            

                
                                                    if let &Opcode::Iconst = v24 {

            

        

            

                1144
            

            

                
            

            

                
                                                        let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                1145
            

            

                
            

            

                
                                                        if v26 == 0x1 {

            

        

            

                1146
            

            

                
            

            

                
                                                            let v238 = C::ty_int(ctx, v2.0);

            

        

            

                1147
            

            

                
            

            

                
                                                            if let Some(v239) = v238 {

            

        

            

                1148
            

            

                
            

            

                
                                                                let v246 =

            

        

            

                1149
            

            

                
            

            

                
                                                                    C::inst_data_etor(ctx, v39);

            

        

            

                1150
            

            

                
            

            

                
                                                                let mut v246 = v246;

            

        

            

                1151
            

            

                
            

            

                
                                                                while let Some(v247) =

            

        

            

                1152
            

            

                
            

            

                
                                                                    v246.next(ctx)

            

        

            

                1153
            

            

                
            

            

                
                                                                {

            

        

            

                1154
            

            

                
            

            

                
                                                                    if let &InstructionData::IntCompare {

            

        

            

                1155
            

            

                
            

            

                
                                                                        opcode: ref v250,

            

        

            

                1156
            

            

                
            

            

                
                                                                        args: ref v251,

            

        

            

                1157
            

            

                
            

            

                
                                                                        cond: ref v252,

            

        

            

                1158
            

            

                
            

            

                
                                                                    } = &v247.1 {

            

        

            

                1159
            

            

                
            

            

                
                                                                        if let &Opcode::Icmp = v250 {

            

        

            

                1160
            

            

                
            

            

                
                                                                            // Rule at src/opts/icmp.isle line 44.

            

        

            

                1161
            

            

                
            

            

                
                                                                            returns.push(v17.0);

            

        

            

                1162
            

            

                
            

            

                
                                                                        }

            

        

            

                1163
            

            

                
            

            

                
                                                                    }

            

        

            

                1164
            

            

                
            

            

                
                                                                }

            

        

            

                1165
            

            

                
            

            

                
                                                            }

            

        

            

                1166
            

            

                
            

            

                
                                                        }

            

        

            

                1167
            

            

                
            

            

                
                                                        let v132 = C::value_type(ctx, v39);

            

        

            

                1168
            

            

                
            

            

                
                                                        let v133 = C::ty_mask(ctx, v132);

            

        

            

                1169
            

            

                
            

            

                
                                                        let v134 = C::u64_and(ctx, v26, v133);

            

        

            

                1170
            

            

                
            

            

                
                                                        let v135 = C::u64_eq(ctx, v133, v134);

            

        

            

                1171
            

            

                
            

            

                
                                                        if v135 == true {

            

        

            

                1172
            

            

                
            

            

                
                                                            // Rule at src/opts/algebraic.isle line 282.

            

        

            

                1173
            

            

                
            

            

                
                                                            returns.push(v17.0);

            

        

            

                1174
            

            

                
            

            

                
                                                        }

            

        

            

                1175
            

            

                
            

            

                
                                                    }

            

        

            

                1176
            

            

                
            

            

                
                                                }

            

        

            

                1177
            

            

                
            

            

                
                                            }

            

        

            

                1178
            

            

                
            

            

                
                                        }

            

        

            

                1179
            

            

                
            

            

                
                                        &Opcode::Sextend => {

            

        

            

                1180
            

            

                
            

            

                
                                            let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                1181
            

            

                
            

            

                
                                            let mut v20 = v20;

            

        

            

                1182
            

            

                
            

            

                
                                            while let Some(v21) = v20.next(ctx) {

            

        

            

                1183
            

            

                
            

            

                
                                                if let &InstructionData::UnaryImm {

            

        

            

                1184
            

            

                
            

            

                
                                                    opcode: ref v24,

            

        

            

                1185
            

            

                
            

            

                
                                                    imm: v25,

            

        

            

                1186
            

            

                
            

            

                
                                                } = &v21.1

            

        

            

                1187
            

            

                
            

            

                
                                                {

            

        

            

                1188
            

            

                
            

            

                
                                                    if let &Opcode::Iconst = v24 {

            

        

            

                1189
            

            

                
            

            

                
                                                        let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                1190
            

            

                
            

            

                
                                                        let v132 = C::value_type(ctx, v39);

            

        

            

                1191
            

            

                
            

            

                
                                                        let v133 = C::ty_mask(ctx, v132);

            

        

            

                1192
            

            

                
            

            

                
                                                        let v136 = C::u64_eq(ctx, v26, v133);

            

        

            

                1193
            

            

                
            

            

                
                                                        if v136 == true {

            

        

            

                1194
            

            

                
            

            

                
                                                            let v137 =

            

        

            

                1195
            

            

                
            

            

                
                                                                constructor_uextend(ctx, v2.0, v39);

            

        

            

                1196
            

            

                
            

            

                
                                                            // Rule at src/opts/algebraic.isle line 288.

            

        

            

                1197
            

            

                
            

            

                
                                                            returns.push(v137);

            

        

            

                1198
            

            

                
            

            

                
                                                        }

            

        

            

                1199
            

            

                
            

            

                
                                                    }

            

        

            

                1200
            

            

                
            

            

                
                                                }

            

        

            

                1201
            

            

                
            

            

                
                                            }

            

        

            

                1202
            

            

                
            

            

                
                                        }

            

        

            

                1203
            

            

                
            

            

                
                                        _ => {}

            

        

            

                1204
            

            

                
            

            

                
                                    }

            

        

            

                1205
            

            

                
            

            

                
                                }

            

        

            

                1206
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                1207
            

            

                
            

            

                
                                    opcode: ref v32,

            

        

            

                1208
            

            

                
            

            

                
                                    imm: v33,

            

        

            

                1209
            

            

                
            

            

                
                                } => {

            

        

            

                1210
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v32 {

            

        

            

                1211
            

            

                
            

            

                
                                        if v2.0 == v29.0 {

            

        

            

                1212
            

            

                
            

            

                
                                            let v34 = C::u64_from_imm64(ctx, v33);

            

        

            

                1213
            

            

                
            

            

                
                                            if v34 == 0x0 {

            

        

            

                1214
            

            

                
            

            

                
                                                let v27 = C::subsume(ctx, v17.0);

            

        

            

                1215
            

            

                
            

            

                
                                                // Rule at src/opts/algebraic.isle line 158.

            

        

            

                1216
            

            

                
            

            

                
                                                returns.push(v27);

            

        

            

                1217
            

            

                
            

            

                
                                            }

            

        

            

                1218
            

            

                
            

            

                
                                            let v56 = C::i64_sextend_imm64(ctx, v2.0, v33);

            

        

            

                1219
            

            

                
            

            

                
                                            if v56 == -0x1 {

            

        

            

                1220
            

            

                
            

            

                
                                                let v35 = C::subsume(ctx, v17.1);

            

        

            

                1221
            

            

                
            

            

                
                                                // Rule at src/opts/algebraic.isle line 152.

            

        

            

                1222
            

            

                
            

            

                
                                                returns.push(v35);

            

        

            

                1223
            

            

                
            

            

                
                                            }

            

        

            

                1224
            

            

                
            

            

                
                                            let v348 = constructor_band(ctx, v2.0, v17.1, v17.0);

            

        

            

                1225
            

            

                
            

            

                
                                            // Rule at src/opts/cprop.isle line 106.

            

        

            

                1226
            

            

                
            

            

                
                                            returns.push(v348);

            

        

            

                1227
            

            

                
            

            

                
                                        }

            

        

            

                1228
            

            

                
            

            

                
                                        let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                1229
            

            

                
            

            

                
                                        if let Some(v47) = v46 {

            

        

            

                1230
            

            

                
            

            

                
                                            if v29.0 == v47 {

            

        

            

                1231
            

            

                
            

            

                
                                                let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                1232
            

            

                
            

            

                
                                                let mut v20 = v20;

            

        

            

                1233
            

            

                
            

            

                
                                                while let Some(v21) = v20.next(ctx) {

            

        

            

                1234
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                1235
            

            

                
            

            

                
                                                        opcode: ref v24,

            

        

            

                1236
            

            

                
            

            

                
                                                        imm: v25,

            

        

            

                1237
            

            

                
            

            

                
                                                    } = &v21.1

            

        

            

                1238
            

            

                
            

            

                
                                                    {

            

        

            

                1239
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v24 {

            

        

            

                1240
            

            

                
            

            

                
                                                            if v21.0 == v29.0 {

            

        

            

                1241
            

            

                
            

            

                
                                                                let v34 =

            

        

            

                1242
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v33);

            

        

            

                1243
            

            

                
            

            

                
                                                                let v26 =

            

        

            

                1244
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v25);

            

        

            

                1245
            

            

                
            

            

                
                                                                let v305 =

            

        

            

                1246
            

            

                
            

            

                
                                                                    C::u64_and(ctx, v34, v26);

            

        

            

                1247
            

            

                
            

            

                
                                                                let v306 =

            

        

            

                1248
            

            

                
            

            

                
                                                                    C::imm64_masked(ctx, v47, v305);

            

        

            

                1249
            

            

                
            

            

                
                                                                let v307 = constructor_iconst(

            

        

            

                1250
            

            

                
            

            

                
                                                                    ctx, v47, v306,

            

        

            

                1251
            

            

                
            

            

                
                                                                );

            

        

            

                1252
            

            

                
            

            

                
                                                                let v308 = C::subsume(ctx, v307);

            

        

            

                1253
            

            

                
            

            

                
                                                                // Rule at src/opts/cprop.isle line 41.

            

        

            

                1254
            

            

                
            

            

                
                                                                returns.push(v308);

            

        

            

                1255
            

            

                
            

            

                
                                                            }

            

        

            

                1256
            

            

                
            

            

                
                                                        }

            

        

            

                1257
            

            

                
            

            

                
                                                    }

            

        

            

                1258
            

            

                
            

            

                
                                                }

            

        

            

                1259
            

            

                
            

            

                
                                            }

            

        

            

                1260
            

            

                
            

            

                
                                        }

            

        

            

                1261
            

            

                
            

            

                
                                        let v138 = C::remat(ctx, arg0);

            

        

            

                1262
            

            

                
            

            

                
                                        // Rule at src/opts/algebraic.isle line 304.

            

        

            

                1263
            

            

                
            

            

                
                                        returns.push(v138);

            

        

            

                1264
            

            

                
            

            

                
                                    }

            

        

            

                1265
            

            

                
            

            

                
                                }

            

        

            

                1266
            

            

                
            

            

                
                                _ => {}

            

        

            

                1267
            

            

                
            

            

                
                            }

            

        

            

                1268
            

            

                
            

            

                
                        }

            

        

            

                1269
            

            

                
            

            

                
                        let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                1270
            

            

                
            

            

                
                        let mut v20 = v20;

            

        

            

                1271
            

            

                
            

            

                
                        while let Some(v21) = v20.next(ctx) {

            

        

            

                1272
            

            

                
            

            

                
                            match &v21.1 {

            

        

            

                1273
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                1274
            

            

                
            

            

                
                                    opcode: ref v40,

            

        

            

                1275
            

            

                
            

            

                
                                    arg: v41,

            

        

            

                1276
            

            

                
            

            

                
                                } => {

            

        

            

                1277
            

            

                
            

            

                
                                    if let &Opcode::Bnot = v40 {

            

        

            

                1278
            

            

                
            

            

                
                                        if v17.0 == v41 {

            

        

            

                1279
            

            

                
            

            

                
                                            let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                1280
            

            

                
            

            

                
                                            if let Some(v47) = v46 {

            

        

            

                1281
            

            

                
            

            

                
                                                let v48 = C::ty_int(ctx, v47);

            

        

            

                1282
            

            

                
            

            

                
                                                if let Some(v49) = v48 {

            

        

            

                1283
            

            

                
            

            

                
                                                    if v21.0 == v49 {

            

        

            

                1284
            

            

                
            

            

                
                                                        let v51 = C::imm64(ctx, 0x0);

            

        

            

                1285
            

            

                
            

            

                
                                                        let v52 = constructor_iconst(ctx, v49, v51);

            

        

            

                1286
            

            

                
            

            

                
                                                        let v53 = C::subsume(ctx, v52);

            

        

            

                1287
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 159.

            

        

            

                1288
            

            

                
            

            

                
                                                        returns.push(v53);

            

        

            

                1289
            

            

                
            

            

                
                                                    }

            

        

            

                1290
            

            

                
            

            

                
                                                }

            

        

            

                1291
            

            

                
            

            

                
                                            }

            

        

            

                1292
            

            

                
            

            

                
                                        }

            

        

            

                1293
            

            

                
            

            

                
                                    }

            

        

            

                1294
            

            

                
            

            

                
                                }

            

        

            

                1295
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                1296
            

            

                
            

            

                
                                    opcode: ref v24,

            

        

            

                1297
            

            

                
            

            

                
                                    imm: v25,

            

        

            

                1298
            

            

                
            

            

                
                                } => {

            

        

            

                1299
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v24 {

            

        

            

                1300
            

            

                
            

            

                
                                        if v2.0 == v21.0 {

            

        

            

                1301
            

            

                
            

            

                
                                            let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                1302
            

            

                
            

            

                
                                            if v26 == 0x0 {

            

        

            

                1303
            

            

                
            

            

                
                                                let v35 = C::subsume(ctx, v17.1);

            

        

            

                1304
            

            

                
            

            

                
                                                // Rule at src/opts/algebraic.isle line 157.

            

        

            

                1305
            

            

                
            

            

                
                                                returns.push(v35);

            

        

            

                1306
            

            

                
            

            

                
                                            }

            

        

            

                1307
            

            

                
            

            

                
                                            let v54 = C::i64_sextend_imm64(ctx, v2.0, v25);

            

        

            

                1308
            

            

                
            

            

                
                                            if v54 == -0x1 {

            

        

            

                1309
            

            

                
            

            

                
                                                let v27 = C::subsume(ctx, v17.0);

            

        

            

                1310
            

            

                
            

            

                
                                                // Rule at src/opts/algebraic.isle line 149.

            

        

            

                1311
            

            

                
            

            

                
                                                returns.push(v27);

            

        

            

                1312
            

            

                
            

            

                
                                            }

            

        

            

                1313
            

            

                
            

            

                
                                        }

            

        

            

                1314
            

            

                
            

            

                
                                        let v138 = C::remat(ctx, arg0);

            

        

            

                1315
            

            

                
            

            

                
                                        // Rule at src/opts/algebraic.isle line 306.

            

        

            

                1316
            

            

                
            

            

                
                                        returns.push(v138);

            

        

            

                1317
            

            

                
            

            

                
                                    }

            

        

            

                1318
            

            

                
            

            

                
                                }

            

        

            

                1319
            

            

                
            

            

                
                                _ => {}

            

        

            

                1320
            

            

                
            

            

                
                            }

            

        

            

                1321
            

            

                
            

            

                
                        }

            

        

            

                1322
            

            

                
            

            

                
                        if v17.0 == v17.1 {

            

        

            

                1323
            

            

                
            

            

                
                            let v27 = C::subsume(ctx, v17.0);

            

        

            

                1324
            

            

                
            

            

                
                            // Rule at src/opts/algebraic.isle line 148.

            

        

            

                1325
            

            

                
            

            

                
                            returns.push(v27);

            

        

            

                1326
            

            

                
            

            

                
                        }

            

        

            

                1327
            

            

                
            

            

                
                    }

            

        

            

                1328
            

            

                
            

            

                
                    &Opcode::Bor => {

            

        

            

                1329
            

            

                
            

            

                
                        let v17 = C::unpack_value_array_2(ctx, v16);

            

        

            

                1330
            

            

                
            

            

                
                        let v28 = C::inst_data_etor(ctx, v17.0);

            

        

            

                1331
            

            

                
            

            

                
                        let mut v28 = v28;

            

        

            

                1332
            

            

                
            

            

                
                        while let Some(v29) = v28.next(ctx) {

            

        

            

                1333
            

            

                
            

            

                
                            match &v29.1 {

            

        

            

                1334
            

            

                
            

            

                
                                &InstructionData::Binary {

            

        

            

                1335
            

            

                
            

            

                
                                    opcode: ref v70,

            

        

            

                1336
            

            

                
            

            

                
                                    args: ref v71,

            

        

            

                1337
            

            

                
            

            

                
                                } => {

            

        

            

                1338
            

            

                
            

            

                
                                    match v70 {

            

        

            

                1339
            

            

                
            

            

                
                                        &Opcode::Band => {

            

        

            

                1340
            

            

                
            

            

                
                                            if v2.0 == v29.0 {

            

        

            

                1341
            

            

                
            

            

                
                                                let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                1342
            

            

                
            

            

                
                                                let mut v20 = v20;

            

        

            

                1343
            

            

                
            

            

                
                                                while let Some(v21) = v20.next(ctx) {

            

        

            

                1344
            

            

                
            

            

                
                                                    match &v21.1 {

            

        

            

                1345
            

            

                
            

            

                
                                                        &InstructionData::Unary {

            

        

            

                1346
            

            

                
            

            

                
                                                            opcode: ref v40,

            

        

            

                1347
            

            

                
            

            

                
                                                            arg: v41,

            

        

            

                1348
            

            

                
            

            

                
                                                        } => {

            

        

            

                1349
            

            

                
            

            

                
                                                            if let &Opcode::Bnot = v40 {

            

        

            

                1350
            

            

                
            

            

                
                                                                if v2.0 == v21.0 {

            

        

            

                1351
            

            

                
            

            

                
                                                                    let v72 =

            

        

            

                1352
            

            

                
            

            

                
                                                                        C::unpack_value_array_2(

            

        

            

                1353
            

            

                
            

            

                
                                                                            ctx, v71,

            

        

            

                1354
            

            

                
            

            

                
                                                                        );

            

        

            

                1355
            

            

                
            

            

                
                                                                    if v41 == v72.1 {

            

        

            

                1356
            

            

                
            

            

                
                                                                        let v75 = constructor_bor(

            

        

            

                1357
            

            

                
            

            

                
                                                                            ctx, v2.0, v72.0, v17.1,

            

        

            

                1358
            

            

                
            

            

                
                                                                        );

            

        

            

                1359
            

            

                
            

            

                
                                                                        // Rule at src/opts/algebraic.isle line 174.

            

        

            

                1360
            

            

                
            

            

                
                                                                        returns.push(v75);

            

        

            

                1361
            

            

                
            

            

                
                                                                    }

            

        

            

                1362
            

            

                
            

            

                
                                                                }

            

        

            

                1363
            

            

                
            

            

                
                                                            }

            

        

            

                1364
            

            

                
            

            

                
                                                        }

            

        

            

                1365
            

            

                
            

            

                
                                                        &InstructionData::UnaryImm {

            

        

            

                1366
            

            

                
            

            

                
                                                            opcode: ref v24,

            

        

            

                1367
            

            

                
            

            

                
                                                            imm: v25,

            

        

            

                1368
            

            

                
            

            

                
                                                        } => {

            

        

            

                1369
            

            

                
            

            

                
                                                            if let &Opcode::Iconst = v24 {

            

        

            

                1370
            

            

                
            

            

                
                                                                if v2.0 == v21.0 {

            

        

            

                1371
            

            

                
            

            

                
                                                                    let v72 =

            

        

            

                1372
            

            

                
            

            

                
                                                                        C::unpack_value_array_2(

            

        

            

                1373
            

            

                
            

            

                
                                                                            ctx, v71,

            

        

            

                1374
            

            

                
            

            

                
                                                                        );

            

        

            

                1375
            

            

                
            

            

                
                                                                    let v82 = C::inst_data_etor(

            

        

            

                1376
            

            

                
            

            

                
                                                                        ctx, v72.1,

            

        

            

                1377
            

            

                
            

            

                
                                                                    );

            

        

            

                1378
            

            

                
            

            

                
                                                                    let mut v82 = v82;

            

        

            

                1379
            

            

                
            

            

                
                                                                    while let Some(v83) =

            

        

            

                1380
            

            

                
            

            

                
                                                                        v82.next(ctx)

            

        

            

                1381
            

            

                
            

            

                
                                                                    {

            

        

            

                1382
            

            

                
            

            

                
                                                                        if let &InstructionData::UnaryImm {

            

        

            

                1383
            

            

                
            

            

                
                                                                            opcode: ref v86,

            

        

            

                1384
            

            

                
            

            

                
                                                                            imm: v87,

            

        

            

                1385
            

            

                
            

            

                
                                                                        } = &v83.1 {

            

        

            

                1386
            

            

                
            

            

                
                                                                            if let &Opcode::Iconst = v86 {

            

        

            

                1387
            

            

                
            

            

                
                                                                                let v89 = C::ty_mask(ctx, v2.0);

            

        

            

                1388
            

            

                
            

            

                
                                                                                let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                1389
            

            

                
            

            

                
                                                                                let v90 = C::u64_and(ctx, v89, v26);

            

        

            

                1390
            

            

                
            

            

                
                                                                                let v88 = C::u64_from_imm64(ctx, v87);

            

        

            

                1391
            

            

                
            

            

                
                                                                                let v91 = C::u64_not(ctx, v88);

            

        

            

                1392
            

            

                
            

            

                
                                                                                let v92 = C::u64_and(ctx, v89, v91);

            

        

            

                1393
            

            

                
            

            

                
                                                                                let v93 = C::u64_eq(ctx, v90, v92);

            

        

            

                1394
            

            

                
            

            

                
                                                                                if v93 == true {

            

        

            

                1395
            

            

                
            

            

                
                                                                                    if v2.0 == v83.0 {

            

        

            

                1396
            

            

                
            

            

                
                                                                                        let v75 = constructor_bor(ctx, v2.0, v72.0, v17.1);

            

        

            

                1397
            

            

                
            

            

                
                                                                                        // Rule at src/opts/algebraic.isle line 194.

            

        

            

                1398
            

            

                
            

            

                
                                                                                        returns.push(v75);

            

        

            

                1399
            

            

                
            

            

                
                                                                                    }

            

        

            

                1400
            

            

                
            

            

                
                                                                                }

            

        

            

                1401
            

            

                
            

            

                
                                                                            }

            

        

            

                1402
            

            

                
            

            

                
                                                                        }

            

        

            

                1403
            

            

                
            

            

                
                                                                    }

            

        

            

                1404
            

            

                
            

            

                
                                                                }

            

        

            

                1405
            

            

                
            

            

                
                                                            }

            

        

            

                1406
            

            

                
            

            

                
                                                        }

            

        

            

                1407
            

            

                
            

            

                
                                                        _ => {}

            

        

            

                1408
            

            

                
            

            

                
                                                    }

            

        

            

                1409
            

            

                
            

            

                
                                                }

            

        

            

                1410
            

            

                
            

            

                
                                            }

            

        

            

                1411
            

            

                
            

            

                
                                        }

            

        

            

                1412
            

            

                
            

            

                
                                        &Opcode::Bor => {

            

        

            

                1413
            

            

                
            

            

                
                                            if v2.0 == v29.0 {

            

        

            

                1414
            

            

                
            

            

                
                                                let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                1415
            

            

                
            

            

                
                                                let mut v20 = v20;

            

        

            

                1416
            

            

                
            

            

                
                                                while let Some(v21) = v20.next(ctx) {

            

        

            

                1417
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                1418
            

            

                
            

            

                
                                                        opcode: ref v24,

            

        

            

                1419
            

            

                
            

            

                
                                                        imm: v25,

            

        

            

                1420
            

            

                
            

            

                
                                                    } = &v21.1

            

        

            

                1421
            

            

                
            

            

                
                                                    {

            

        

            

                1422
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v24 {

            

        

            

                1423
            

            

                
            

            

                
                                                            if v2.0 == v21.0 {

            

        

            

                1424
            

            

                
            

            

                
                                                                let v72 = C::unpack_value_array_2(

            

        

            

                1425
            

            

                
            

            

                
                                                                    ctx, v71,

            

        

            

                1426
            

            

                
            

            

                
                                                                );

            

        

            

                1427
            

            

                
            

            

                
                                                                let v82 =

            

        

            

                1428
            

            

                
            

            

                
                                                                    C::inst_data_etor(ctx, v72.1);

            

        

            

                1429
            

            

                
            

            

                
                                                                let mut v82 = v82;

            

        

            

                1430
            

            

                
            

            

                
                                                                while let Some(v83) = v82.next(ctx)

            

        

            

                1431
            

            

                
            

            

                
                                                                {

            

        

            

                1432
            

            

                
            

            

                
                                                                    if let &InstructionData::UnaryImm {

            

        

            

                1433
            

            

                
            

            

                
                                                                        opcode: ref v86,

            

        

            

                1434
            

            

                
            

            

                
                                                                        imm: v87,

            

        

            

                1435
            

            

                
            

            

                
                                                                    } = &v83.1 {

            

        

            

                1436
            

            

                
            

            

                
                                                                        if let &Opcode::Iconst = v86 {

            

        

            

                1437
            

            

                
            

            

                
                                                                            if v2.0 == v83.0 {

            

        

            

                1438
            

            

                
            

            

                
                                                                                let v376 = constructor_bor(ctx, v2.0, v72.1, v17.1);

            

        

            

                1439
            

            

                
            

            

                
                                                                                let v377 = constructor_bor(ctx, v2.0, v72.0, v376);

            

        

            

                1440
            

            

                
            

            

                
                                                                                // Rule at src/opts/cprop.isle line 156.

            

        

            

                1441
            

            

                
            

            

                
                                                                                returns.push(v377);

            

        

            

                1442
            

            

                
            

            

                
                                                                            }

            

        

            

                1443
            

            

                
            

            

                
                                                                        }

            

        

            

                1444
            

            

                
            

            

                
                                                                    }

            

        

            

                1445
            

            

                
            

            

                
                                                                }

            

        

            

                1446
            

            

                
            

            

                
                                                            }

            

        

            

                1447
            

            

                
            

            

                
                                                        }

            

        

            

                1448
            

            

                
            

            

                
                                                    }

            

        

            

                1449
            

            

                
            

            

                
                                                }

            

        

            

                1450
            

            

                
            

            

                
                                            }

            

        

            

                1451
            

            

                
            

            

                
                                        }

            

        

            

                1452
            

            

                
            

            

                
                                        _ => {}

            

        

            

                1453
            

            

                
            

            

                
                                    }

            

        

            

                1454
            

            

                
            

            

                
                                }

            

        

            

                1455
            

            

                
            

            

                
                                &InstructionData::IntCompare {

            

        

            

                1456
            

            

                
            

            

                
                                    opcode: ref v240,

            

        

            

                1457
            

            

                
            

            

                
                                    args: ref v241,

            

        

            

                1458
            

            

                
            

            

                
                                    cond: ref v242,

            

        

            

                1459
            

            

                
            

            

                
                                } => {

            

        

            

                1460
            

            

                
            

            

                
                                    if let &Opcode::Icmp = v240 {

            

        

            

                1461
            

            

                
            

            

                
                                        if v2.0 == v29.0 {

            

        

            

                1462
            

            

                
            

            

                
                                            let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                1463
            

            

                
            

            

                
                                            let mut v20 = v20;

            

        

            

                1464
            

            

                
            

            

                
                                            while let Some(v21) = v20.next(ctx) {

            

        

            

                1465
            

            

                
            

            

                
                                                if let &InstructionData::IntCompare {

            

        

            

                1466
            

            

                
            

            

                
                                                    opcode: ref v265,

            

        

            

                1467
            

            

                
            

            

                
                                                    args: ref v266,

            

        

            

                1468
            

            

                
            

            

                
                                                    cond: ref v267,

            

        

            

                1469
            

            

                
            

            

                
                                                } = &v21.1

            

        

            

                1470
            

            

                
            

            

                
                                                {

            

        

            

                1471
            

            

                
            

            

                
                                                    if let &Opcode::Icmp = v265 {

            

        

            

                1472
            

            

                
            

            

                
                                                        let v271 = constructor_intcc_comparable(

            

        

            

                1473
            

            

                
            

            

                
                                                            ctx, v242, v267,

            

        

            

                1474
            

            

                
            

            

                
                                                        );

            

        

            

                1475
            

            

                
            

            

                
                                                        if let Some(v272) = v271 {

            

        

            

                1476
            

            

                
            

            

                
                                                            if v2.0 == v21.0 {

            

        

            

                1477
            

            

                
            

            

                
                                                                let v243 = C::unpack_value_array_2(

            

        

            

                1478
            

            

                
            

            

                
                                                                    ctx, v241,

            

        

            

                1479
            

            

                
            

            

                
                                                                );

            

        

            

                1480
            

            

                
            

            

                
                                                                let v268 = C::unpack_value_array_2(

            

        

            

                1481
            

            

                
            

            

                
                                                                    ctx, v266,

            

        

            

                1482
            

            

                
            

            

                
                                                                );

            

        

            

                1483
            

            

                
            

            

                
                                                                if v243.0 == v268.0 {

            

        

            

                1484
            

            

                
            

            

                
                                                                    if v243.1 == v268.1 {

            

        

            

                1485
            

            

                
            

            

                
                                                                        let v273 = constructor_decompose_intcc(ctx, v242);

            

        

            

                1486
            

            

                
            

            

                
                                                                        let v274 = constructor_decompose_intcc(ctx, v267);

            

        

            

                1487
            

            

                
            

            

                
                                                                        let v277 = C::u64_or(

            

        

            

                1488
            

            

                
            

            

                
                                                                            ctx, v273, v274,

            

        

            

                1489
            

            

                
            

            

                
                                                                        );

            

        

            

                1490
            

            

                
            

            

                
                                                                        let v278 = constructor_compose_icmp(ctx, v2.0, v277, v272, v243.0, v243.1);

            

        

            

                1491
            

            

                
            

            

                
                                                                        // Rule at src/opts/icmp.isle line 132.

            

        

            

                1492
            

            

                
            

            

                
                                                                        returns.push(v278);

            

        

            

                1493
            

            

                
            

            

                
                                                                    }

            

        

            

                1494
            

            

                
            

            

                
                                                                }

            

        

            

                1495
            

            

                
            

            

                
                                                            }

            

        

            

                1496
            

            

                
            

            

                
                                                        }

            

        

            

                1497
            

            

                
            

            

                
                                                    }

            

        

            

                1498
            

            

                
            

            

                
                                                }

            

        

            

                1499
            

            

                
            

            

                
                                            }

            

        

            

                1500
            

            

                
            

            

                
                                        }

            

        

            

                1501
            

            

                
            

            

                
                                    }

            

        

            

                1502
            

            

                
            

            

                
                                }

            

        

            

                1503
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                1504
            

            

                
            

            

                
                                    opcode: ref v38,

            

        

            

                1505
            

            

                
            

            

                
                                    arg: v39,

            

        

            

                1506
            

            

                
            

            

                
                                } => {

            

        

            

                1507
            

            

                
            

            

                
                                    if let &Opcode::Bnot = v38 {

            

        

            

                1508
            

            

                
            

            

                
                                        let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                1509
            

            

                
            

            

                
                                        if let Some(v47) = v46 {

            

        

            

                1510
            

            

                
            

            

                
                                            let v48 = C::ty_int(ctx, v47);

            

        

            

                1511
            

            

                
            

            

                
                                            if let Some(v49) = v48 {

            

        

            

                1512
            

            

                
            

            

                
                                                if v17.1 == v39 {

            

        

            

                1513
            

            

                
            

            

                
                                                    if v29.0 == v49 {

            

        

            

                1514
            

            

                
            

            

                
                                                        let v57 = C::ty_mask(ctx, v49);

            

        

            

                1515
            

            

                
            

            

                
                                                        let v58 = C::imm64(ctx, v57);

            

        

            

                1516
            

            

                
            

            

                
                                                        let v59 = constructor_iconst(ctx, v49, v58);

            

        

            

                1517
            

            

                
            

            

                
                                                        let v60 = C::subsume(ctx, v59);

            

        

            

                1518
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 145.

            

        

            

                1519
            

            

                
            

            

                
                                                        returns.push(v60);

            

        

            

                1520
            

            

                
            

            

                
                                                    }

            

        

            

                1521
            

            

                
            

            

                
                                                }

            

        

            

                1522
            

            

                
            

            

                
                                            }

            

        

            

                1523
            

            

                
            

            

                
                                        }

            

        

            

                1524
            

            

                
            

            

                
                                        if v2.0 == v29.0 {

            

        

            

                1525
            

            

                
            

            

                
                                            let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                1526
            

            

                
            

            

                
                                            let mut v20 = v20;

            

        

            

                1527
            

            

                
            

            

                
                                            while let Some(v21) = v20.next(ctx) {

            

        

            

                1528
            

            

                
            

            

                
                                                if let &InstructionData::Binary {

            

        

            

                1529
            

            

                
            

            

                
                                                    opcode: ref v76,

            

        

            

                1530
            

            

                
            

            

                
                                                    args: ref v77,

            

        

            

                1531
            

            

                
            

            

                
                                                } = &v21.1

            

        

            

                1532
            

            

                
            

            

                
                                                {

            

        

            

                1533
            

            

                
            

            

                
                                                    if let &Opcode::Band = v76 {

            

        

            

                1534
            

            

                
            

            

                
                                                        if v2.0 == v21.0 {

            

        

            

                1535
            

            

                
            

            

                
                                                            let v78 =

            

        

            

                1536
            

            

                
            

            

                
                                                                C::unpack_value_array_2(ctx, v77);

            

        

            

                1537
            

            

                
            

            

                
                                                            if v39 == v78.1 {

            

        

            

                1538
            

            

                
            

            

                
                                                                let v81 = constructor_bor(

            

        

            

                1539
            

            

                
            

            

                
                                                                    ctx, v2.0, v78.0, v17.0,

            

        

            

                1540
            

            

                
            

            

                
                                                                );

            

        

            

                1541
            

            

                
            

            

                
                                                                // Rule at src/opts/algebraic.isle line 183.

            

        

            

                1542
            

            

                
            

            

                
                                                                returns.push(v81);

            

        

            

                1543
            

            

                
            

            

                
                                                            }

            

        

            

                1544
            

            

                
            

            

                
                                                        }

            

        

            

                1545
            

            

                
            

            

                
                                                    }

            

        

            

                1546
            

            

                
            

            

                
                                                }

            

        

            

                1547
            

            

                
            

            

                
                                            }

            

        

            

                1548
            

            

                
            

            

                
                                        }

            

        

            

                1549
            

            

                
            

            

                
                                    }

            

        

            

                1550
            

            

                
            

            

                
                                }

            

        

            

                1551
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                1552
            

            

                
            

            

                
                                    opcode: ref v32,

            

        

            

                1553
            

            

                
            

            

                
                                    imm: v33,

            

        

            

                1554
            

            

                
            

            

                
                                } => {

            

        

            

                1555
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v32 {

            

        

            

                1556
            

            

                
            

            

                
                                        if v2.0 == v29.0 {

            

        

            

                1557
            

            

                
            

            

                
                                            let v34 = C::u64_from_imm64(ctx, v33);

            

        

            

                1558
            

            

                
            

            

                
                                            if v34 == 0x0 {

            

        

            

                1559
            

            

                
            

            

                
                                                let v35 = C::subsume(ctx, v17.1);

            

        

            

                1560
            

            

                
            

            

                
                                                // Rule at src/opts/algebraic.isle line 118.

            

        

            

                1561
            

            

                
            

            

                
                                                returns.push(v35);

            

        

            

                1562
            

            

                
            

            

                
                                            }

            

        

            

                1563
            

            

                
            

            

                
                                            let v347 = constructor_bor(ctx, v2.0, v17.1, v17.0);

            

        

            

                1564
            

            

                
            

            

                
                                            // Rule at src/opts/cprop.isle line 103.

            

        

            

                1565
            

            

                
            

            

                
                                            returns.push(v347);

            

        

            

                1566
            

            

                
            

            

                
                                        }

            

        

            

                1567
            

            

                
            

            

                
                                        let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                1568
            

            

                
            

            

                
                                        if let Some(v47) = v46 {

            

        

            

                1569
            

            

                
            

            

                
                                            if v29.0 == v47 {

            

        

            

                1570
            

            

                
            

            

                
                                                let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                1571
            

            

                
            

            

                
                                                let mut v20 = v20;

            

        

            

                1572
            

            

                
            

            

                
                                                while let Some(v21) = v20.next(ctx) {

            

        

            

                1573
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                1574
            

            

                
            

            

                
                                                        opcode: ref v24,

            

        

            

                1575
            

            

                
            

            

                
                                                        imm: v25,

            

        

            

                1576
            

            

                
            

            

                
                                                    } = &v21.1

            

        

            

                1577
            

            

                
            

            

                
                                                    {

            

        

            

                1578
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v24 {

            

        

            

                1579
            

            

                
            

            

                
                                                            if v21.0 == v29.0 {

            

        

            

                1580
            

            

                
            

            

                
                                                                let v34 =

            

        

            

                1581
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v33);

            

        

            

                1582
            

            

                
            

            

                
                                                                let v26 =

            

        

            

                1583
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v25);

            

        

            

                1584
            

            

                
            

            

                
                                                                let v301 = C::u64_or(ctx, v34, v26);

            

        

            

                1585
            

            

                
            

            

                
                                                                let v302 =

            

        

            

                1586
            

            

                
            

            

                
                                                                    C::imm64_masked(ctx, v47, v301);

            

        

            

                1587
            

            

                
            

            

                
                                                                let v303 = constructor_iconst(

            

        

            

                1588
            

            

                
            

            

                
                                                                    ctx, v47, v302,

            

        

            

                1589
            

            

                
            

            

                
                                                                );

            

        

            

                1590
            

            

                
            

            

                
                                                                let v304 = C::subsume(ctx, v303);

            

        

            

                1591
            

            

                
            

            

                
                                                                // Rule at src/opts/cprop.isle line 35.

            

        

            

                1592
            

            

                
            

            

                
                                                                returns.push(v304);

            

        

            

                1593
            

            

                
            

            

                
                                                            }

            

        

            

                1594
            

            

                
            

            

                
                                                        }

            

        

            

                1595
            

            

                
            

            

                
                                                    }

            

        

            

                1596
            

            

                
            

            

                
                                                }

            

        

            

                1597
            

            

                
            

            

                
                                            }

            

        

            

                1598
            

            

                
            

            

                
                                        }

            

        

            

                1599
            

            

                
            

            

                
                                        let v138 = C::remat(ctx, arg0);

            

        

            

                1600
            

            

                
            

            

                
                                        // Rule at src/opts/algebraic.isle line 308.

            

        

            

                1601
            

            

                
            

            

                
                                        returns.push(v138);

            

        

            

                1602
            

            

                
            

            

                
                                    }

            

        

            

                1603
            

            

                
            

            

                
                                }

            

        

            

                1604
            

            

                
            

            

                
                                _ => {}

            

        

            

                1605
            

            

                
            

            

                
                            }

            

        

            

                1606
            

            

                
            

            

                
                        }

            

        

            

                1607
            

            

                
            

            

                
                        let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                1608
            

            

                
            

            

                
                        let mut v20 = v20;

            

        

            

                1609
            

            

                
            

            

                
                        while let Some(v21) = v20.next(ctx) {

            

        

            

                1610
            

            

                
            

            

                
                            match &v21.1 {

            

        

            

                1611
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                1612
            

            

                
            

            

                
                                    opcode: ref v40,

            

        

            

                1613
            

            

                
            

            

                
                                    arg: v41,

            

        

            

                1614
            

            

                
            

            

                
                                } => {

            

        

            

                1615
            

            

                
            

            

                
                                    if let &Opcode::Bnot = v40 {

            

        

            

                1616
            

            

                
            

            

                
                                        if v17.0 == v41 {

            

        

            

                1617
            

            

                
            

            

                
                                            let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                1618
            

            

                
            

            

                
                                            if let Some(v47) = v46 {

            

        

            

                1619
            

            

                
            

            

                
                                                let v48 = C::ty_int(ctx, v47);

            

        

            

                1620
            

            

                
            

            

                
                                                if let Some(v49) = v48 {

            

        

            

                1621
            

            

                
            

            

                
                                                    if v21.0 == v49 {

            

        

            

                1622
            

            

                
            

            

                
                                                        let v57 = C::ty_mask(ctx, v49);

            

        

            

                1623
            

            

                
            

            

                
                                                        let v58 = C::imm64(ctx, v57);

            

        

            

                1624
            

            

                
            

            

                
                                                        let v59 = constructor_iconst(ctx, v49, v58);

            

        

            

                1625
            

            

                
            

            

                
                                                        let v60 = C::subsume(ctx, v59);

            

        

            

                1626
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 144.

            

        

            

                1627
            

            

                
            

            

                
                                                        returns.push(v60);

            

        

            

                1628
            

            

                
            

            

                
                                                    }

            

        

            

                1629
            

            

                
            

            

                
                                                }

            

        

            

                1630
            

            

                
            

            

                
                                            }

            

        

            

                1631
            

            

                
            

            

                
                                        }

            

        

            

                1632
            

            

                
            

            

                
                                    }

            

        

            

                1633
            

            

                
            

            

                
                                }

            

        

            

                1634
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                1635
            

            

                
            

            

                
                                    opcode: ref v24,

            

        

            

                1636
            

            

                
            

            

                
                                    imm: v25,

            

        

            

                1637
            

            

                
            

            

                
                                } => {

            

        

            

                1638
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v24 {

            

        

            

                1639
            

            

                
            

            

                
                                        let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                1640
            

            

                
            

            

                
                                        if v26 == 0x0 {

            

        

            

                1641
            

            

                
            

            

                
                                            if v2.0 == v21.0 {

            

        

            

                1642
            

            

                
            

            

                
                                                let v27 = C::subsume(ctx, v17.0);

            

        

            

                1643
            

            

                
            

            

                
                                                // Rule at src/opts/algebraic.isle line 114.

            

        

            

                1644
            

            

                
            

            

                
                                                returns.push(v27);

            

        

            

                1645
            

            

                
            

            

                
                                            }

            

        

            

                1646
            

            

                
            

            

                
                                        }

            

        

            

                1647
            

            

                
            

            

                
                                        let v138 = C::remat(ctx, arg0);

            

        

            

                1648
            

            

                
            

            

                
                                        // Rule at src/opts/algebraic.isle line 310.

            

        

            

                1649
            

            

                
            

            

                
                                        returns.push(v138);

            

        

            

                1650
            

            

                
            

            

                
                                    }

            

        

            

                1651
            

            

                
            

            

                
                                }

            

        

            

                1652
            

            

                
            

            

                
                                _ => {}

            

        

            

                1653
            

            

                
            

            

                
                            }

            

        

            

                1654
            

            

                
            

            

                
                        }

            

        

            

                1655
            

            

                
            

            

                
                        if v17.0 == v17.1 {

            

        

            

                1656
            

            

                
            

            

                
                            let v27 = C::subsume(ctx, v17.0);

            

        

            

                1657
            

            

                
            

            

                
                            // Rule at src/opts/algebraic.isle line 122.

            

        

            

                1658
            

            

                
            

            

                
                            returns.push(v27);

            

        

            

                1659
            

            

                
            

            

                
                        }

            

        

            

                1660
            

            

                
            

            

                
                    }

            

        

            

                1661
            

            

                
            

            

                
                    &Opcode::Bxor => {

            

        

            

                1662
            

            

                
            

            

                
                        let v17 = C::unpack_value_array_2(ctx, v16);

            

        

            

                1663
            

            

                
            

            

                
                        let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                1664
            

            

                
            

            

                
                        let mut v20 = v20;

            

        

            

                1665
            

            

                
            

            

                
                        while let Some(v21) = v20.next(ctx) {

            

        

            

                1666
            

            

                
            

            

                
                            match &v21.1 {

            

        

            

                1667
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                1668
            

            

                
            

            

                
                                    opcode: ref v40,

            

        

            

                1669
            

            

                
            

            

                
                                    arg: v41,

            

        

            

                1670
            

            

                
            

            

                
                                } => {

            

        

            

                1671
            

            

                
            

            

                
                                    if let &Opcode::Bnot = v40 {

            

        

            

                1672
            

            

                
            

            

                
                                        let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                1673
            

            

                
            

            

                
                                        if let Some(v47) = v46 {

            

        

            

                1674
            

            

                
            

            

                
                                            let v48 = C::ty_int(ctx, v47);

            

        

            

                1675
            

            

                
            

            

                
                                            if let Some(v49) = v48 {

            

        

            

                1676
            

            

                
            

            

                
                                                if v17.0 == v41 {

            

        

            

                1677
            

            

                
            

            

                
                                                    if v21.0 == v49 {

            

        

            

                1678
            

            

                
            

            

                
                                                        let v57 = C::ty_mask(ctx, v49);

            

        

            

                1679
            

            

                
            

            

                
                                                        let v58 = C::imm64(ctx, v57);

            

        

            

                1680
            

            

                
            

            

                
                                                        let v59 = constructor_iconst(ctx, v49, v58);

            

        

            

                1681
            

            

                
            

            

                
                                                        let v60 = C::subsume(ctx, v59);

            

        

            

                1682
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 142.

            

        

            

                1683
            

            

                
            

            

                
                                                        returns.push(v60);

            

        

            

                1684
            

            

                
            

            

                
                                                    }

            

        

            

                1685
            

            

                
            

            

                
                                                }

            

        

            

                1686
            

            

                
            

            

                
                                            }

            

        

            

                1687
            

            

                
            

            

                
                                        }

            

        

            

                1688
            

            

                
            

            

                
                                    }

            

        

            

                1689
            

            

                
            

            

                
                                }

            

        

            

                1690
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                1691
            

            

                
            

            

                
                                    opcode: ref v24,

            

        

            

                1692
            

            

                
            

            

                
                                    imm: v25,

            

        

            

                1693
            

            

                
            

            

                
                                } => {

            

        

            

                1694
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v24 {

            

        

            

                1695
            

            

                
            

            

                
                                        if v2.0 == v21.0 {

            

        

            

                1696
            

            

                
            

            

                
                                            let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                1697
            

            

                
            

            

                
                                            if v26 == 0x0 {

            

        

            

                1698
            

            

                
            

            

                
                                                let v27 = C::subsume(ctx, v17.0);

            

        

            

                1699
            

            

                
            

            

                
                                                // Rule at src/opts/algebraic.isle line 126.

            

        

            

                1700
            

            

                
            

            

                
                                                returns.push(v27);

            

        

            

                1701
            

            

                
            

            

                
                                            }

            

        

            

                1702
            

            

                
            

            

                
                                            let v54 = C::i64_sextend_imm64(ctx, v2.0, v25);

            

        

            

                1703
            

            

                
            

            

                
                                            if v54 == -0x1 {

            

        

            

                1704
            

            

                
            

            

                
                                                let v145 = constructor_bnot(ctx, v2.0, v17.0);

            

        

            

                1705
            

            

                
            

            

                
                                                // Rule at src/opts/algebraic.isle line 326.

            

        

            

                1706
            

            

                
            

            

                
                                                returns.push(v145);

            

        

            

                1707
            

            

                
            

            

                
                                            }

            

        

            

                1708
            

            

                
            

            

                
                                            let v28 = C::inst_data_etor(ctx, v17.0);

            

        

            

                1709
            

            

                
            

            

                
                                            let mut v28 = v28;

            

        

            

                1710
            

            

                
            

            

                
                                            while let Some(v29) = v28.next(ctx) {

            

        

            

                1711
            

            

                
            

            

                
                                                if let &InstructionData::Binary {

            

        

            

                1712
            

            

                
            

            

                
                                                    opcode: ref v70,

            

        

            

                1713
            

            

                
            

            

                
                                                    args: ref v71,

            

        

            

                1714
            

            

                
            

            

                
                                                } = &v29.1

            

        

            

                1715
            

            

                
            

            

                
                                                {

            

        

            

                1716
            

            

                
            

            

                
                                                    if let &Opcode::Bxor = v70 {

            

        

            

                1717
            

            

                
            

            

                
                                                        if v2.0 == v29.0 {

            

        

            

                1718
            

            

                
            

            

                
                                                            let v72 =

            

        

            

                1719
            

            

                
            

            

                
                                                                C::unpack_value_array_2(ctx, v71);

            

        

            

                1720
            

            

                
            

            

                
                                                            let v82 = C::inst_data_etor(ctx, v72.1);

            

        

            

                1721
            

            

                
            

            

                
                                                            let mut v82 = v82;

            

        

            

                1722
            

            

                
            

            

                
                                                            while let Some(v83) = v82.next(ctx) {

            

        

            

                1723
            

            

                
            

            

                
                                                                if let &InstructionData::UnaryImm {

            

        

            

                1724
            

            

                
            

            

                
                                                                    opcode: ref v86,

            

        

            

                1725
            

            

                
            

            

                
                                                                    imm: v87,

            

        

            

                1726
            

            

                
            

            

                
                                                                } = &v83.1 {

            

        

            

                1727
            

            

                
            

            

                
                                                                    if let &Opcode::Iconst = v86 {

            

        

            

                1728
            

            

                
            

            

                
                                                                        if v2.0 == v83.0 {

            

        

            

                1729
            

            

                
            

            

                
                                                                            let v380 = constructor_bxor(ctx, v2.0, v72.1, v17.1);

            

        

            

                1730
            

            

                
            

            

                
                                                                            let v381 = constructor_bxor(ctx, v2.0, v72.0, v380);

            

        

            

                1731
            

            

                
            

            

                
                                                                            // Rule at src/opts/cprop.isle line 162.

            

        

            

                1732
            

            

                
            

            

                
                                                                            returns.push(v381);

            

        

            

                1733
            

            

                
            

            

                
                                                                        }

            

        

            

                1734
            

            

                
            

            

                
                                                                    }

            

        

            

                1735
            

            

                
            

            

                
                                                                }

            

        

            

                1736
            

            

                
            

            

                
                                                            }

            

        

            

                1737
            

            

                
            

            

                
                                                        }

            

        

            

                1738
            

            

                
            

            

                
                                                    }

            

        

            

                1739
            

            

                
            

            

                
                                                }

            

        

            

                1740
            

            

                
            

            

                
                                            }

            

        

            

                1741
            

            

                
            

            

                
                                        }

            

        

            

                1742
            

            

                
            

            

                
                                        let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                1743
            

            

                
            

            

                
                                        if let Some(v47) = v46 {

            

        

            

                1744
            

            

                
            

            

                
                                            if v21.0 == v47 {

            

        

            

                1745
            

            

                
            

            

                
                                                let v28 = C::inst_data_etor(ctx, v17.0);

            

        

            

                1746
            

            

                
            

            

                
                                                let mut v28 = v28;

            

        

            

                1747
            

            

                
            

            

                
                                                while let Some(v29) = v28.next(ctx) {

            

        

            

                1748
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                1749
            

            

                
            

            

                
                                                        opcode: ref v32,

            

        

            

                1750
            

            

                
            

            

                
                                                        imm: v33,

            

        

            

                1751
            

            

                
            

            

                
                                                    } = &v29.1

            

        

            

                1752
            

            

                
            

            

                
                                                    {

            

        

            

                1753
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v32 {

            

        

            

                1754
            

            

                
            

            

                
                                                            if v21.0 == v29.0 {

            

        

            

                1755
            

            

                
            

            

                
                                                                let v34 =

            

        

            

                1756
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v33);

            

        

            

                1757
            

            

                
            

            

                
                                                                let v26 =

            

        

            

                1758
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v25);

            

        

            

                1759
            

            

                
            

            

                
                                                                let v309 =

            

        

            

                1760
            

            

                
            

            

                
                                                                    C::u64_xor(ctx, v34, v26);

            

        

            

                1761
            

            

                
            

            

                
                                                                let v310 =

            

        

            

                1762
            

            

                
            

            

                
                                                                    C::imm64_masked(ctx, v47, v309);

            

        

            

                1763
            

            

                
            

            

                
                                                                let v311 = constructor_iconst(

            

        

            

                1764
            

            

                
            

            

                
                                                                    ctx, v47, v310,

            

        

            

                1765
            

            

                
            

            

                
                                                                );

            

        

            

                1766
            

            

                
            

            

                
                                                                let v312 = C::subsume(ctx, v311);

            

        

            

                1767
            

            

                
            

            

                
                                                                // Rule at src/opts/cprop.isle line 47.

            

        

            

                1768
            

            

                
            

            

                
                                                                returns.push(v312);

            

        

            

                1769
            

            

                
            

            

                
                                                            }

            

        

            

                1770
            

            

                
            

            

                
                                                        }

            

        

            

                1771
            

            

                
            

            

                
                                                    }

            

        

            

                1772
            

            

                
            

            

                
                                                }

            

        

            

                1773
            

            

                
            

            

                
                                            }

            

        

            

                1774
            

            

                
            

            

                
                                        }

            

        

            

                1775
            

            

                
            

            

                
                                        let v138 = C::remat(ctx, arg0);

            

        

            

                1776
            

            

                
            

            

                
                                        // Rule at src/opts/algebraic.isle line 314.

            

        

            

                1777
            

            

                
            

            

                
                                        returns.push(v138);

            

        

            

                1778
            

            

                
            

            

                
                                    }

            

        

            

                1779
            

            

                
            

            

                
                                }

            

        

            

                1780
            

            

                
            

            

                
                                _ => {}

            

        

            

                1781
            

            

                
            

            

                
                            }

            

        

            

                1782
            

            

                
            

            

                
                        }

            

        

            

                1783
            

            

                
            

            

                
                        let v28 = C::inst_data_etor(ctx, v17.0);

            

        

            

                1784
            

            

                
            

            

                
                        let mut v28 = v28;

            

        

            

                1785
            

            

                
            

            

                
                        while let Some(v29) = v28.next(ctx) {

            

        

            

                1786
            

            

                
            

            

                
                            match &v29.1 {

            

        

            

                1787
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                1788
            

            

                
            

            

                
                                    opcode: ref v38,

            

        

            

                1789
            

            

                
            

            

                
                                    arg: v39,

            

        

            

                1790
            

            

                
            

            

                
                                } => {

            

        

            

                1791
            

            

                
            

            

                
                                    if let &Opcode::Bnot = v38 {

            

        

            

                1792
            

            

                
            

            

                
                                        if v17.1 == v39 {

            

        

            

                1793
            

            

                
            

            

                
                                            let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                1794
            

            

                
            

            

                
                                            if let Some(v47) = v46 {

            

        

            

                1795
            

            

                
            

            

                
                                                let v48 = C::ty_int(ctx, v47);

            

        

            

                1796
            

            

                
            

            

                
                                                if let Some(v49) = v48 {

            

        

            

                1797
            

            

                
            

            

                
                                                    if v29.0 == v49 {

            

        

            

                1798
            

            

                
            

            

                
                                                        let v57 = C::ty_mask(ctx, v49);

            

        

            

                1799
            

            

                
            

            

                
                                                        let v58 = C::imm64(ctx, v57);

            

        

            

                1800
            

            

                
            

            

                
                                                        let v59 = constructor_iconst(ctx, v49, v58);

            

        

            

                1801
            

            

                
            

            

                
                                                        let v60 = C::subsume(ctx, v59);

            

        

            

                1802
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 143.

            

        

            

                1803
            

            

                
            

            

                
                                                        returns.push(v60);

            

        

            

                1804
            

            

                
            

            

                
                                                    }

            

        

            

                1805
            

            

                
            

            

                
                                                }

            

        

            

                1806
            

            

                
            

            

                
                                            }

            

        

            

                1807
            

            

                
            

            

                
                                        }

            

        

            

                1808
            

            

                
            

            

                
                                    }

            

        

            

                1809
            

            

                
            

            

                
                                }

            

        

            

                1810
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                1811
            

            

                
            

            

                
                                    opcode: ref v32,

            

        

            

                1812
            

            

                
            

            

                
                                    imm: v33,

            

        

            

                1813
            

            

                
            

            

                
                                } => {

            

        

            

                1814
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v32 {

            

        

            

                1815
            

            

                
            

            

                
                                        if v2.0 == v29.0 {

            

        

            

                1816
            

            

                
            

            

                
                                            let v34 = C::u64_from_imm64(ctx, v33);

            

        

            

                1817
            

            

                
            

            

                
                                            if v34 == 0x0 {

            

        

            

                1818
            

            

                
            

            

                
                                                let v35 = C::subsume(ctx, v17.1);

            

        

            

                1819
            

            

                
            

            

                
                                                // Rule at src/opts/algebraic.isle line 130.

            

        

            

                1820
            

            

                
            

            

                
                                                returns.push(v35);

            

        

            

                1821
            

            

                
            

            

                
                                            }

            

        

            

                1822
            

            

                
            

            

                
                                            let v349 = constructor_bxor(ctx, v2.0, v17.1, v17.0);

            

        

            

                1823
            

            

                
            

            

                
                                            // Rule at src/opts/cprop.isle line 109.

            

        

            

                1824
            

            

                
            

            

                
                                            returns.push(v349);

            

        

            

                1825
            

            

                
            

            

                
                                        }

            

        

            

                1826
            

            

                
            

            

                
                                        let v138 = C::remat(ctx, arg0);

            

        

            

                1827
            

            

                
            

            

                
                                        // Rule at src/opts/algebraic.isle line 312.

            

        

            

                1828
            

            

                
            

            

                
                                        returns.push(v138);

            

        

            

                1829
            

            

                
            

            

                
                                    }

            

        

            

                1830
            

            

                
            

            

                
                                }

            

        

            

                1831
            

            

                
            

            

                
                                _ => {}

            

        

            

                1832
            

            

                
            

            

                
                            }

            

        

            

                1833
            

            

                
            

            

                
                        }

            

        

            

                1834
            

            

                
            

            

                
                        if v17.0 == v17.1 {

            

        

            

                1835
            

            

                
            

            

                
                            let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                1836
            

            

                
            

            

                
                            if let Some(v47) = v46 {

            

        

            

                1837
            

            

                
            

            

                
                                let v48 = C::ty_int(ctx, v47);

            

        

            

                1838
            

            

                
            

            

                
                                if let Some(v49) = v48 {

            

        

            

                1839
            

            

                
            

            

                
                                    let v51 = C::imm64(ctx, 0x0);

            

        

            

                1840
            

            

                
            

            

                
                                    let v52 = constructor_iconst(ctx, v49, v51);

            

        

            

                1841
            

            

                
            

            

                
                                    let v53 = C::subsume(ctx, v52);

            

        

            

                1842
            

            

                
            

            

                
                                    // Rule at src/opts/algebraic.isle line 136.

            

        

            

                1843
            

            

                
            

            

                
                                    returns.push(v53);

            

        

            

                1844
            

            

                
            

            

                
                                }

            

        

            

                1845
            

            

                
            

            

                
                            }

            

        

            

                1846
            

            

                
            

            

                
                        }

            

        

            

                1847
            

            

                
            

            

                
                    }

            

        

            

                1848
            

            

                
            

            

                
                    &Opcode::Rotl => {

            

        

            

                1849
            

            

                
            

            

                
                        let v17 = C::unpack_value_array_2(ctx, v16);

            

        

            

                1850
            

            

                
            

            

                
                        let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                1851
            

            

                
            

            

                
                        let mut v20 = v20;

            

        

            

                1852
            

            

                
            

            

                
                        while let Some(v21) = v20.next(ctx) {

            

        

            

                1853
            

            

                
            

            

                
                            if let &InstructionData::UnaryImm {

            

        

            

                1854
            

            

                
            

            

                
                                opcode: ref v24,

            

        

            

                1855
            

            

                
            

            

                
                                imm: v25,

            

        

            

                1856
            

            

                
            

            

                
                            } = &v21.1

            

        

            

                1857
            

            

                
            

            

                
                            {

            

        

            

                1858
            

            

                
            

            

                
                                if let &Opcode::Iconst = v24 {

            

        

            

                1859
            

            

                
            

            

                
                                    let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                1860
            

            

                
            

            

                
                                    if v26 == 0x0 {

            

        

            

                1861
            

            

                
            

            

                
                                        if v2.0 == v21.0 {

            

        

            

                1862
            

            

                
            

            

                
                                            let v27 = C::subsume(ctx, v17.0);

            

        

            

                1863
            

            

                
            

            

                
                                            // Rule at src/opts/algebraic.isle line 108.

            

        

            

                1864
            

            

                
            

            

                
                                            returns.push(v27);

            

        

            

                1865
            

            

                
            

            

                
                                        }

            

        

            

                1866
            

            

                
            

            

                
                                    }

            

        

            

                1867
            

            

                
            

            

                
                                }

            

        

            

                1868
            

            

                
            

            

                
                            }

            

        

            

                1869
            

            

                
            

            

                
                        }

            

        

            

                1870
            

            

                
            

            

                
                    }

            

        

            

                1871
            

            

                
            

            

                
                    &Opcode::Rotr => {

            

        

            

                1872
            

            

                
            

            

                
                        let v17 = C::unpack_value_array_2(ctx, v16);

            

        

            

                1873
            

            

                
            

            

                
                        let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                1874
            

            

                
            

            

                
                        let mut v20 = v20;

            

        

            

                1875
            

            

                
            

            

                
                        while let Some(v21) = v20.next(ctx) {

            

        

            

                1876
            

            

                
            

            

                
                            if let &InstructionData::UnaryImm {

            

        

            

                1877
            

            

                
            

            

                
                                opcode: ref v24,

            

        

            

                1878
            

            

                
            

            

                
                                imm: v25,

            

        

            

                1879
            

            

                
            

            

                
                            } = &v21.1

            

        

            

                1880
            

            

                
            

            

                
                            {

            

        

            

                1881
            

            

                
            

            

                
                                if let &Opcode::Iconst = v24 {

            

        

            

                1882
            

            

                
            

            

                
                                    let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                1883
            

            

                
            

            

                
                                    if v26 == 0x0 {

            

        

            

                1884
            

            

                
            

            

                
                                        if v2.0 == v21.0 {

            

        

            

                1885
            

            

                
            

            

                
                                            let v27 = C::subsume(ctx, v17.0);

            

        

            

                1886
            

            

                
            

            

                
                                            // Rule at src/opts/algebraic.isle line 104.

            

        

            

                1887
            

            

                
            

            

                
                                            returns.push(v27);

            

        

            

                1888
            

            

                
            

            

                
                                        }

            

        

            

                1889
            

            

                
            

            

                
                                    }

            

        

            

                1890
            

            

                
            

            

                
                                }

            

        

            

                1891
            

            

                
            

            

                
                            }

            

        

            

                1892
            

            

                
            

            

                
                        }

            

        

            

                1893
            

            

                
            

            

                
                    }

            

        

            

                1894
            

            

                
            

            

                
                    &Opcode::Ishl => {

            

        

            

                1895
            

            

                
            

            

                
                        let v17 = C::unpack_value_array_2(ctx, v16);

            

        

            

                1896
            

            

                
            

            

                
                        let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                1897
            

            

                
            

            

                
                        let mut v20 = v20;

            

        

            

                1898
            

            

                
            

            

                
                        while let Some(v21) = v20.next(ctx) {

            

        

            

                1899
            

            

                
            

            

                
                            if let &InstructionData::UnaryImm {

            

        

            

                1900
            

            

                
            

            

                
                                opcode: ref v24,

            

        

            

                1901
            

            

                
            

            

                
                                imm: v25,

            

        

            

                1902
            

            

                
            

            

                
                            } = &v21.1

            

        

            

                1903
            

            

                
            

            

                
                            {

            

        

            

                1904
            

            

                
            

            

                
                                if let &Opcode::Iconst = v24 {

            

        

            

                1905
            

            

                
            

            

                
                                    let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                1906
            

            

                
            

            

                
                                    if let Some(v47) = v46 {

            

        

            

                1907
            

            

                
            

            

                
                                        let v28 = C::inst_data_etor(ctx, v17.0);

            

        

            

                1908
            

            

                
            

            

                
                                        let mut v28 = v28;

            

        

            

                1909
            

            

                
            

            

                
                                        while let Some(v29) = v28.next(ctx) {

            

        

            

                1910
            

            

                
            

            

                
                                            match &v29.1 {

            

        

            

                1911
            

            

                
            

            

                
                                                &InstructionData::Binary {

            

        

            

                1912
            

            

                
            

            

                
                                                    opcode: ref v70,

            

        

            

                1913
            

            

                
            

            

                
                                                    args: ref v71,

            

        

            

                1914
            

            

                
            

            

                
                                                } => {

            

        

            

                1915
            

            

                
            

            

                
                                                    match v70 {

            

        

            

                1916
            

            

                
            

            

                
                                                        &Opcode::Ushr => {

            

        

            

                1917
            

            

                
            

            

                
                                                            if v29.0 == v47 {

            

        

            

                1918
            

            

                
            

            

                
                                                                let v72 = C::unpack_value_array_2(

            

        

            

                1919
            

            

                
            

            

                
                                                                    ctx, v71,

            

        

            

                1920
            

            

                
            

            

                
                                                                );

            

        

            

                1921
            

            

                
            

            

                
                                                                let v82 =

            

        

            

                1922
            

            

                
            

            

                
                                                                    C::inst_data_etor(ctx, v72.1);

            

        

            

                1923
            

            

                
            

            

                
                                                                let mut v82 = v82;

            

        

            

                1924
            

            

                
            

            

                
                                                                while let Some(v83) = v82.next(ctx)

            

        

            

                1925
            

            

                
            

            

                
                                                                {

            

        

            

                1926
            

            

                
            

            

                
                                                                    if let &InstructionData::UnaryImm {

            

        

            

                1927
            

            

                
            

            

                
                                                                        opcode: ref v86,

            

        

            

                1928
            

            

                
            

            

                
                                                                        imm: v87,

            

        

            

                1929
            

            

                
            

            

                
                                                                    } = &v83.1 {

            

        

            

                1930
            

            

                
            

            

                
                                                                        if let &Opcode::Iconst = v86 {

            

        

            

                1931
            

            

                
            

            

                
                                                                            if v25 == v87 {

            

        

            

                1932
            

            

                
            

            

                
                                                                                let v111 = C::imm64(ctx, 0xFFFFFFFFFFFFFFFF);

            

        

            

                1933
            

            

                
            

            

                
                                                                                let v112 = C::imm64_shl(ctx, v47, v111, v87);

            

        

            

                1934
            

            

                
            

            

                
                                                                                let v113 = constructor_iconst(ctx, v47, v112);

            

        

            

                1935
            

            

                
            

            

                
                                                                                let v114 = constructor_band(ctx, v47, v72.0, v113);

            

        

            

                1936
            

            

                
            

            

                
                                                                                // Rule at src/opts/algebraic.isle line 222.

            

        

            

                1937
            

            

                
            

            

                
                                                                                returns.push(v114);

            

        

            

                1938
            

            

                
            

            

                
                                                                            }

            

        

            

                1939
            

            

                
            

            

                
                                                                        }

            

        

            

                1940
            

            

                
            

            

                
                                                                    }

            

        

            

                1941
            

            

                
            

            

                
                                                                }

            

        

            

                1942
            

            

                
            

            

                
                                                            }

            

        

            

                1943
            

            

                
            

            

                
                                                        }

            

        

            

                1944
            

            

                
            

            

                
                                                        &Opcode::Sshr => {

            

        

            

                1945
            

            

                
            

            

                
                                                            if v29.0 == v47 {

            

        

            

                1946
            

            

                
            

            

                
                                                                let v72 = C::unpack_value_array_2(

            

        

            

                1947
            

            

                
            

            

                
                                                                    ctx, v71,

            

        

            

                1948
            

            

                
            

            

                
                                                                );

            

        

            

                1949
            

            

                
            

            

                
                                                                let v82 =

            

        

            

                1950
            

            

                
            

            

                
                                                                    C::inst_data_etor(ctx, v72.1);

            

        

            

                1951
            

            

                
            

            

                
                                                                let mut v82 = v82;

            

        

            

                1952
            

            

                
            

            

                
                                                                while let Some(v83) = v82.next(ctx)

            

        

            

                1953
            

            

                
            

            

                
                                                                {

            

        

            

                1954
            

            

                
            

            

                
                                                                    if let &InstructionData::UnaryImm {

            

        

            

                1955
            

            

                
            

            

                
                                                                        opcode: ref v86,

            

        

            

                1956
            

            

                
            

            

                
                                                                        imm: v87,

            

        

            

                1957
            

            

                
            

            

                
                                                                    } = &v83.1 {

            

        

            

                1958
            

            

                
            

            

                
                                                                        if let &Opcode::Iconst = v86 {

            

        

            

                1959
            

            

                
            

            

                
                                                                            if v25 == v87 {

            

        

            

                1960
            

            

                
            

            

                
                                                                                let v111 = C::imm64(ctx, 0xFFFFFFFFFFFFFFFF);

            

        

            

                1961
            

            

                
            

            

                
                                                                                let v112 = C::imm64_shl(ctx, v47, v111, v87);

            

        

            

                1962
            

            

                
            

            

                
                                                                                let v113 = constructor_iconst(ctx, v47, v112);

            

        

            

                1963
            

            

                
            

            

                
                                                                                let v114 = constructor_band(ctx, v47, v72.0, v113);

            

        

            

                1964
            

            

                
            

            

                
                                                                                // Rule at src/opts/algebraic.isle line 227.

            

        

            

                1965
            

            

                
            

            

                
                                                                                returns.push(v114);

            

        

            

                1966
            

            

                
            

            

                
                                                                            }

            

        

            

                1967
            

            

                
            

            

                
                                                                        }

            

        

            

                1968
            

            

                
            

            

                
                                                                    }

            

        

            

                1969
            

            

                
            

            

                
                                                                }

            

        

            

                1970
            

            

                
            

            

                
                                                            }

            

        

            

                1971
            

            

                
            

            

                
                                                        }

            

        

            

                1972
            

            

                
            

            

                
                                                        _ => {}

            

        

            

                1973
            

            

                
            

            

                
                                                    }

            

        

            

                1974
            

            

                
            

            

                
                                                }

            

        

            

                1975
            

            

                
            

            

                
                                                &InstructionData::UnaryImm {

            

        

            

                1976
            

            

                
            

            

                
                                                    opcode: ref v32,

            

        

            

                1977
            

            

                
            

            

                
                                                    imm: v33,

            

        

            

                1978
            

            

                
            

            

                
                                                } => {

            

        

            

                1979
            

            

                
            

            

                
                                                    if let &Opcode::Iconst = v32 {

            

        

            

                1980
            

            

                
            

            

                
                                                        if v29.0 == v47 {

            

        

            

                1981
            

            

                
            

            

                
                                                            let v320 =

            

        

            

                1982
            

            

                
            

            

                
                                                                C::imm64_shl(ctx, v47, v33, v25);

            

        

            

                1983
            

            

                
            

            

                
                                                            let v321 =

            

        

            

                1984
            

            

                
            

            

                
                                                                constructor_iconst(ctx, v47, v320);

            

        

            

                1985
            

            

                
            

            

                
                                                            let v322 = C::subsume(ctx, v321);

            

        

            

                1986
            

            

                
            

            

                
                                                            // Rule at src/opts/cprop.isle line 58.

            

        

            

                1987
            

            

                
            

            

                
                                                            returns.push(v322);

            

        

            

                1988
            

            

                
            

            

                
                                                        }

            

        

            

                1989
            

            

                
            

            

                
                                                    }

            

        

            

                1990
            

            

                
            

            

                
                                                }

            

        

            

                1991
            

            

                
            

            

                
                                                _ => {}

            

        

            

                1992
            

            

                
            

            

                
                                            }

            

        

            

                1993
            

            

                
            

            

                
                                        }

            

        

            

                1994
            

            

                
            

            

                
                                    }

            

        

            

                1995
            

            

                
            

            

                
                                    let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                1996
            

            

                
            

            

                
                                    if v26 == 0x0 {

            

        

            

                1997
            

            

                
            

            

                
                                        if v2.0 == v21.0 {

            

        

            

                1998
            

            

                
            

            

                
                                            let v27 = C::subsume(ctx, v17.0);

            

        

            

                1999
            

            

                
            

            

                
                                            // Rule at src/opts/algebraic.isle line 92.

            

        

            

                2000
            

            

                
            

            

                
                                            returns.push(v27);

            

        

            

                2001
            

            

                
            

            

                
                                        }

            

        

            

                2002
            

            

                
            

            

                
                                    }

            

        

            

                2003
            

            

                
            

            

                
                                }

            

        

            

                2004
            

            

                
            

            

                
                            }

            

        

            

                2005
            

            

                
            

            

                
                        }

            

        

            

                2006
            

            

                
            

            

                
                    }

            

        

            

                2007
            

            

                
            

            

                
                    &Opcode::Ushr => {

            

        

            

                2008
            

            

                
            

            

                
                        let v17 = C::unpack_value_array_2(ctx, v16);

            

        

            

                2009
            

            

                
            

            

                
                        let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                2010
            

            

                
            

            

                
                        let mut v20 = v20;

            

        

            

                2011
            

            

                
            

            

                
                        while let Some(v21) = v20.next(ctx) {

            

        

            

                2012
            

            

                
            

            

                
                            if let &InstructionData::UnaryImm {

            

        

            

                2013
            

            

                
            

            

                
                                opcode: ref v24,

            

        

            

                2014
            

            

                
            

            

                
                                imm: v25,

            

        

            

                2015
            

            

                
            

            

                
                            } = &v21.1

            

        

            

                2016
            

            

                
            

            

                
                            {

            

        

            

                2017
            

            

                
            

            

                
                                if let &Opcode::Iconst = v24 {

            

        

            

                2018
            

            

                
            

            

                
                                    let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                2019
            

            

                
            

            

                
                                    if let Some(v47) = v46 {

            

        

            

                2020
            

            

                
            

            

                
                                        let v28 = C::inst_data_etor(ctx, v17.0);

            

        

            

                2021
            

            

                
            

            

                
                                        let mut v28 = v28;

            

        

            

                2022
            

            

                
            

            

                
                                        while let Some(v29) = v28.next(ctx) {

            

        

            

                2023
            

            

                
            

            

                
                                            match &v29.1 {

            

        

            

                2024
            

            

                
            

            

                
                                                &InstructionData::Binary {

            

        

            

                2025
            

            

                
            

            

                
                                                    opcode: ref v70,

            

        

            

                2026
            

            

                
            

            

                
                                                    args: ref v71,

            

        

            

                2027
            

            

                
            

            

                
                                                } => {

            

        

            

                2028
            

            

                
            

            

                
                                                    if let &Opcode::Ishl = v70 {

            

        

            

                2029
            

            

                
            

            

                
                                                        let v48 = C::ty_int(ctx, v47);

            

        

            

                2030
            

            

                
            

            

                
                                                        if let Some(v49) = v48 {

            

        

            

                2031
            

            

                
            

            

                
                                                            if v29.0 == v49 {

            

        

            

                2032
            

            

                
            

            

                
                                                                let v72 = C::unpack_value_array_2(

            

        

            

                2033
            

            

                
            

            

                
                                                                    ctx, v71,

            

        

            

                2034
            

            

                
            

            

                
                                                                );

            

        

            

                2035
            

            

                
            

            

                
                                                                let v82 =

            

        

            

                2036
            

            

                
            

            

                
                                                                    C::inst_data_etor(ctx, v72.1);

            

        

            

                2037
            

            

                
            

            

                
                                                                let mut v82 = v82;

            

        

            

                2038
            

            

                
            

            

                
                                                                while let Some(v83) = v82.next(ctx)

            

        

            

                2039
            

            

                
            

            

                
                                                                {

            

        

            

                2040
            

            

                
            

            

                
                                                                    if let &InstructionData::UnaryImm {

            

        

            

                2041
            

            

                
            

            

                
                                                                        opcode: ref v86,

            

        

            

                2042
            

            

                
            

            

                
                                                                        imm: v87,

            

        

            

                2043
            

            

                
            

            

                
                                                                    } = &v83.1 {

            

        

            

                2044
            

            

                
            

            

                
                                                                        if let &Opcode::Iconst = v86 {

            

        

            

                2045
            

            

                
            

            

                
                                                                            if v25 == v87 {

            

        

            

                2046
            

            

                
            

            

                
                                                                                let v57 = C::ty_mask(ctx, v49);

            

        

            

                2047
            

            

                
            

            

                
                                                                                let v58 = C::imm64(ctx, v57);

            

        

            

                2048
            

            

                
            

            

                
                                                                                let v115 = C::imm64_ushr(ctx, v49, v58, v87);

            

        

            

                2049
            

            

                
            

            

                
                                                                                let v116 = constructor_iconst(ctx, v49, v115);

            

        

            

                2050
            

            

                
            

            

                
                                                                                let v117 = constructor_band(ctx, v49, v72.0, v116);

            

        

            

                2051
            

            

                
            

            

                
                                                                                // Rule at src/opts/algebraic.isle line 237.

            

        

            

                2052
            

            

                
            

            

                
                                                                                returns.push(v117);

            

        

            

                2053
            

            

                
            

            

                
                                                                            }

            

        

            

                2054
            

            

                
            

            

                
                                                                        }

            

        

            

                2055
            

            

                
            

            

                
                                                                    }

            

        

            

                2056
            

            

                
            

            

                
                                                                }

            

        

            

                2057
            

            

                
            

            

                
                                                            }

            

        

            

                2058
            

            

                
            

            

                
                                                        }

            

        

            

                2059
            

            

                
            

            

                
                                                    }

            

        

            

                2060
            

            

                
            

            

                
                                                }

            

        

            

                2061
            

            

                
            

            

                
                                                &InstructionData::UnaryImm {

            

        

            

                2062
            

            

                
            

            

                
                                                    opcode: ref v32,

            

        

            

                2063
            

            

                
            

            

                
                                                    imm: v33,

            

        

            

                2064
            

            

                
            

            

                
                                                } => {

            

        

            

                2065
            

            

                
            

            

                
                                                    if let &Opcode::Iconst = v32 {

            

        

            

                2066
            

            

                
            

            

                
                                                        if v29.0 == v47 {

            

        

            

                2067
            

            

                
            

            

                
                                                            let v323 =

            

        

            

                2068
            

            

                
            

            

                
                                                                C::imm64_ushr(ctx, v47, v33, v25);

            

        

            

                2069
            

            

                
            

            

                
                                                            let v324 =

            

        

            

                2070
            

            

                
            

            

                
                                                                constructor_iconst(ctx, v47, v323);

            

        

            

                2071
            

            

                
            

            

                
                                                            let v325 = C::subsume(ctx, v324);

            

        

            

                2072
            

            

                
            

            

                
                                                            // Rule at src/opts/cprop.isle line 63.

            

        

            

                2073
            

            

                
            

            

                
                                                            returns.push(v325);

            

        

            

                2074
            

            

                
            

            

                
                                                        }

            

        

            

                2075
            

            

                
            

            

                
                                                    }

            

        

            

                2076
            

            

                
            

            

                
                                                }

            

        

            

                2077
            

            

                
            

            

                
                                                _ => {}

            

        

            

                2078
            

            

                
            

            

                
                                            }

            

        

            

                2079
            

            

                
            

            

                
                                        }

            

        

            

                2080
            

            

                
            

            

                
                                    }

            

        

            

                2081
            

            

                
            

            

                
                                    let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                2082
            

            

                
            

            

                
                                    if v26 == 0x0 {

            

        

            

                2083
            

            

                
            

            

                
                                        if v2.0 == v21.0 {

            

        

            

                2084
            

            

                
            

            

                
                                            let v27 = C::subsume(ctx, v17.0);

            

        

            

                2085
            

            

                
            

            

                
                                            // Rule at src/opts/algebraic.isle line 96.

            

        

            

                2086
            

            

                
            

            

                
                                            returns.push(v27);

            

        

            

                2087
            

            

                
            

            

                
                                        }

            

        

            

                2088
            

            

                
            

            

                
                                    }

            

        

            

                2089
            

            

                
            

            

                
                                }

            

        

            

                2090
            

            

                
            

            

                
                            }

            

        

            

                2091
            

            

                
            

            

                
                        }

            

        

            

                2092
            

            

                
            

            

                
                    }

            

        

            

                2093
            

            

                
            

            

                
                    &Opcode::Sshr => {

            

        

            

                2094
            

            

                
            

            

                
                        let v17 = C::unpack_value_array_2(ctx, v16);

            

        

            

                2095
            

            

                
            

            

                
                        let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                2096
            

            

                
            

            

                
                        let mut v20 = v20;

            

        

            

                2097
            

            

                
            

            

                
                        while let Some(v21) = v20.next(ctx) {

            

        

            

                2098
            

            

                
            

            

                
                            if let &InstructionData::UnaryImm {

            

        

            

                2099
            

            

                
            

            

                
                                opcode: ref v24,

            

        

            

                2100
            

            

                
            

            

                
                                imm: v25,

            

        

            

                2101
            

            

                
            

            

                
                            } = &v21.1

            

        

            

                2102
            

            

                
            

            

                
                            {

            

        

            

                2103
            

            

                
            

            

                
                                if let &Opcode::Iconst = v24 {

            

        

            

                2104
            

            

                
            

            

                
                                    let v28 = C::inst_data_etor(ctx, v17.0);

            

        

            

                2105
            

            

                
            

            

                
                                    let mut v28 = v28;

            

        

            

                2106
            

            

                
            

            

                
                                    while let Some(v29) = v28.next(ctx) {

            

        

            

                2107
            

            

                
            

            

                
                                        match &v29.1 {

            

        

            

                2108
            

            

                
            

            

                
                                            &InstructionData::Binary {

            

        

            

                2109
            

            

                
            

            

                
                                                opcode: ref v70,

            

        

            

                2110
            

            

                
            

            

                
                                                args: ref v71,

            

        

            

                2111
            

            

                
            

            

                
                                            } => {

            

        

            

                2112
            

            

                
            

            

                
                                                if let &Opcode::Ishl = v70 {

            

        

            

                2113
            

            

                
            

            

                
                                                    if v2.0 == v29.0 {

            

        

            

                2114
            

            

                
            

            

                
                                                        let v72 = C::unpack_value_array_2(ctx, v71);

            

        

            

                2115
            

            

                
            

            

                
                                                        let v82 = C::inst_data_etor(ctx, v72.1);

            

        

            

                2116
            

            

                
            

            

                
                                                        let mut v82 = v82;

            

        

            

                2117
            

            

                
            

            

                
                                                        while let Some(v83) = v82.next(ctx) {

            

        

            

                2118
            

            

                
            

            

                
                                                            if let &InstructionData::UnaryImm {

            

        

            

                2119
            

            

                
            

            

                
                                                                opcode: ref v86,

            

        

            

                2120
            

            

                
            

            

                
                                                                imm: v87,

            

        

            

                2121
            

            

                
            

            

                
                                                            } = &v83.1

            

        

            

                2122
            

            

                
            

            

                
                                                            {

            

        

            

                2123
            

            

                
            

            

                
                                                                if let &Opcode::Iconst = v86 {

            

        

            

                2124
            

            

                
            

            

                
                                                                    if v25 == v87 {

            

        

            

                2125
            

            

                
            

            

                
                                                                        let v118 =

            

        

            

                2126
            

            

                
            

            

                
                                                                            C::inst_data_etor(

            

        

            

                2127
            

            

                
            

            

                
                                                                                ctx, v72.0,

            

        

            

                2128
            

            

                
            

            

                
                                                                            );

            

        

            

                2129
            

            

                
            

            

                
                                                                        let mut v118 = v118;

            

        

            

                2130
            

            

                
            

            

                
                                                                        while let Some(v119) =

            

        

            

                2131
            

            

                
            

            

                
                                                                            v118.next(ctx)

            

        

            

                2132
            

            

                
            

            

                
                                                                        {

            

        

            

                2133
            

            

                
            

            

                
                                                                            if let &InstructionData::Unary {

            

        

            

                2134
            

            

                
            

            

                
                                                                                opcode: ref v122,

            

        

            

                2135
            

            

                
            

            

                
                                                                                arg: v123,

            

        

            

                2136
            

            

                
            

            

                
                                                                            } = &v119.1 {

            

        

            

                2137
            

            

                
            

            

                
                                                                                match v122 {

            

        

            

                2138
            

            

                
            

            

                
                                                                                    &Opcode::Uextend => {

            

        

            

                2139
            

            

                
            

            

                
                                                                                        if v2.0 == v119.0 {

            

        

            

                2140
            

            

                
            

            

                
                                                                                            let v88 = C::u64_from_imm64(ctx, v87);

            

        

            

                2141
            

            

                
            

            

                
                                                                                            let v125 = C::ty_bits_u64(ctx, v2.0);

            

        

            

                2142
            

            

                
            

            

                
                                                                                            let v124 = C::value_type(ctx, v123);

            

        

            

                2143
            

            

                
            

            

                
                                                                                            let v126 = C::ty_bits_u64(ctx, v124);

            

        

            

                2144
            

            

                
            

            

                
                                                                                            let v127 = C::u64_sub(ctx, v125, v126);

            

        

            

                2145
            

            

                
            

            

                
                                                                                            let v128 = C::u64_eq(ctx, v88, v127);

            

        

            

                2146
            

            

                
            

            

                
                                                                                            if v128 == true {

            

        

            

                2147
            

            

                
            

            

                
                                                                                                let v129 = constructor_sextend(ctx, v2.0, v123);

            

        

            

                2148
            

            

                
            

            

                
                                                                                                // Rule at src/opts/algebraic.isle line 247.

            

        

            

                2149
            

            

                
            

            

                
                                                                                                returns.push(v129);

            

        

            

                2150
            

            

                
            

            

                
                                                                                            }

            

        

            

                2151
            

            

                
            

            

                
                                                                                            let v130 = C::u64_lt(ctx, v88, v127);

            

        

            

                2152
            

            

                
            

            

                
                                                                                            if v130 == true {

            

        

            

                2153
            

            

                
            

            

                
                                                                                                // Rule at src/opts/algebraic.isle line 259.

            

        

            

                2154
            

            

                
            

            

                
                                                                                                returns.push(v72.0);

            

        

            

                2155
            

            

                
            

            

                
                                                                                            }

            

        

            

                2156
            

            

                
            

            

                
                                                                                        }

            

        

            

                2157
            

            

                
            

            

                
                                                                                    }

            

        

            

                2158
            

            

                
            

            

                
                                                                                    &Opcode::Sextend => {

            

        

            

                2159
            

            

                
            

            

                
                                                                                        let v88 = C::u64_from_imm64(ctx, v87);

            

        

            

                2160
            

            

                
            

            

                
                                                                                        let v125 = C::ty_bits_u64(ctx, v2.0);

            

        

            

                2161
            

            

                
            

            

                
                                                                                        let v124 = C::value_type(ctx, v123);

            

        

            

                2162
            

            

                
            

            

                
                                                                                        let v126 = C::ty_bits_u64(ctx, v124);

            

        

            

                2163
            

            

                
            

            

                
                                                                                        let v127 = C::u64_sub(ctx, v125, v126);

            

        

            

                2164
            

            

                
            

            

                
                                                                                        let v131 = C::u64_le(ctx, v88, v127);

            

        

            

                2165
            

            

                
            

            

                
                                                                                        if v131 == true {

            

        

            

                2166
            

            

                
            

            

                
                                                                                            if v2.0 == v119.0 {

            

        

            

                2167
            

            

                
            

            

                
                                                                                                // Rule at src/opts/algebraic.isle line 270.

            

        

            

                2168
            

            

                
            

            

                
                                                                                                returns.push(v72.0);

            

        

            

                2169
            

            

                
            

            

                
                                                                                            }

            

        

            

                2170
            

            

                
            

            

                
                                                                                        }

            

        

            

                2171
            

            

                
            

            

                
                                                                                    }

            

        

            

                2172
            

            

                
            

            

                
                                                                                    _ => {}

            

        

            

                2173
            

            

                
            

            

                
                                                                                }

            

        

            

                2174
            

            

                
            

            

                
                                                                            }

            

        

            

                2175
            

            

                
            

            

                
                                                                        }

            

        

            

                2176
            

            

                
            

            

                
                                                                    }

            

        

            

                2177
            

            

                
            

            

                
                                                                }

            

        

            

                2178
            

            

                
            

            

                
                                                            }

            

        

            

                2179
            

            

                
            

            

                
                                                        }

            

        

            

                2180
            

            

                
            

            

                
                                                    }

            

        

            

                2181
            

            

                
            

            

                
                                                }

            

        

            

                2182
            

            

                
            

            

                
                                            }

            

        

            

                2183
            

            

                
            

            

                
                                            &InstructionData::UnaryImm {

            

        

            

                2184
            

            

                
            

            

                
                                                opcode: ref v32,

            

        

            

                2185
            

            

                
            

            

                
                                                imm: v33,

            

        

            

                2186
            

            

                
            

            

                
                                            } => {

            

        

            

                2187
            

            

                
            

            

                
                                                if let &Opcode::Iconst = v32 {

            

        

            

                2188
            

            

                
            

            

                
                                                    let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                2189
            

            

                
            

            

                
                                                    if let Some(v47) = v46 {

            

        

            

                2190
            

            

                
            

            

                
                                                        if v29.0 == v47 {

            

        

            

                2191
            

            

                
            

            

                
                                                            let v326 =

            

        

            

                2192
            

            

                
            

            

                
                                                                C::imm64_sshr(ctx, v47, v33, v25);

            

        

            

                2193
            

            

                
            

            

                
                                                            let v327 =

            

        

            

                2194
            

            

                
            

            

                
                                                                constructor_iconst(ctx, v47, v326);

            

        

            

                2195
            

            

                
            

            

                
                                                            let v328 = C::subsume(ctx, v327);

            

        

            

                2196
            

            

                
            

            

                
                                                            // Rule at src/opts/cprop.isle line 68.

            

        

            

                2197
            

            

                
            

            

                
                                                            returns.push(v328);

            

        

            

                2198
            

            

                
            

            

                
                                                        }

            

        

            

                2199
            

            

                
            

            

                
                                                    }

            

        

            

                2200
            

            

                
            

            

                
                                                }

            

        

            

                2201
            

            

                
            

            

                
                                            }

            

        

            

                2202
            

            

                
            

            

                
                                            _ => {}

            

        

            

                2203
            

            

                
            

            

                
                                        }

            

        

            

                2204
            

            

                
            

            

                
                                    }

            

        

            

                2205
            

            

                
            

            

                
                                    let v26 = C::u64_from_imm64(ctx, v25);

            

        

            

                2206
            

            

                
            

            

                
                                    if v26 == 0x0 {

            

        

            

                2207
            

            

                
            

            

                
                                        if v2.0 == v21.0 {

            

        

            

                2208
            

            

                
            

            

                
                                            let v27 = C::subsume(ctx, v17.0);

            

        

            

                2209
            

            

                
            

            

                
                                            // Rule at src/opts/algebraic.isle line 100.

            

        

            

                2210
            

            

                
            

            

                
                                            returns.push(v27);

            

        

            

                2211
            

            

                
            

            

                
                                        }

            

        

            

                2212
            

            

                
            

            

                
                                    }

            

        

            

                2213
            

            

                
            

            

                
                                }

            

        

            

                2214
            

            

                
            

            

                
                            }

            

        

            

                2215
            

            

                
            

            

                
                        }

            

        

            

                2216
            

            

                
            

            

                
                    }

            

        

            

                2217
            

            

                
            

            

                
                    &Opcode::Fmul => {

            

        

            

                2218
            

            

                
            

            

                
                        let v17 = C::unpack_value_array_2(ctx, v16);

            

        

            

                2219
            

            

                
            

            

                
                        let v20 = C::inst_data_etor(ctx, v17.1);

            

        

            

                2220
            

            

                
            

            

                
                        let mut v20 = v20;

            

        

            

                2221
            

            

                
            

            

                
                        while let Some(v21) = v20.next(ctx) {

            

        

            

                2222
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                2223
            

            

                
            

            

                
                                opcode: ref v40,

            

        

            

                2224
            

            

                
            

            

                
                                arg: v41,

            

        

            

                2225
            

            

                
            

            

                
                            } = &v21.1

            

        

            

                2226
            

            

                
            

            

                
                            {

            

        

            

                2227
            

            

                
            

            

                
                                if let &Opcode::Fneg = v40 {

            

        

            

                2228
            

            

                
            

            

                
                                    if v2.0 == v21.0 {

            

        

            

                2229
            

            

                
            

            

                
                                        let v28 = C::inst_data_etor(ctx, v17.0);

            

        

            

                2230
            

            

                
            

            

                
                                        let mut v28 = v28;

            

        

            

                2231
            

            

                
            

            

                
                                        while let Some(v29) = v28.next(ctx) {

            

        

            

                2232
            

            

                
            

            

                
                                            if let &InstructionData::Unary {

            

        

            

                2233
            

            

                
            

            

                
                                                opcode: ref v38,

            

        

            

                2234
            

            

                
            

            

                
                                                arg: v39,

            

        

            

                2235
            

            

                
            

            

                
                                            } = &v29.1

            

        

            

                2236
            

            

                
            

            

                
                                            {

            

        

            

                2237
            

            

                
            

            

                
                                                if let &Opcode::Fneg = v38 {

            

        

            

                2238
            

            

                
            

            

                
                                                    if v2.0 == v29.0 {

            

        

            

                2239
            

            

                
            

            

                
                                                        let v211 =

            

        

            

                2240
            

            

                
            

            

                
                                                            constructor_fmul(ctx, v2.0, v39, v41);

            

        

            

                2241
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 410.

            

        

            

                2242
            

            

                
            

            

                
                                                        returns.push(v211);

            

        

            

                2243
            

            

                
            

            

                
                                                    }

            

        

            

                2244
            

            

                
            

            

                
                                                }

            

        

            

                2245
            

            

                
            

            

                
                                            }

            

        

            

                2246
            

            

                
            

            

                
                                        }

            

        

            

                2247
            

            

                
            

            

                
                                    }

            

        

            

                2248
            

            

                
            

            

                
                                }

            

        

            

                2249
            

            

                
            

            

                
                            }

            

        

            

                2250
            

            

                
            

            

                
                        }

            

        

            

                2251
            

            

                
            

            

                
                    }

            

        

            

                2252
            

            

                
            

            

                
                    _ => {}

            

        

            

                2253
            

            

                
            

            

                
                }

            

        

            

                2254
            

            

                
            

            

                
            }

            

        

            

                2255
            

            

                
            

            

                
            &InstructionData::IntCompare {

            

        

            

                2256
            

            

                
            

            

                
                opcode: ref v146,

            

        

            

                2257
            

            

                
            

            

                
                args: ref v147,

            

        

            

                2258
            

            

                
            

            

                
                cond: ref v148,

            

        

            

                2259
            

            

                
            

            

                
            } => {

            

        

            

                2260
            

            

                
            

            

                
                if let &Opcode::Icmp = v146 {

            

        

            

                2261
            

            

                
            

            

                
                    match v148 {

            

        

            

                2262
            

            

                
            

            

                
                        &IntCC::Equal => {

            

        

            

                2263
            

            

                
            

            

                
                            let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                2264
            

            

                
            

            

                
                            if let Some(v47) = v46 {

            

        

            

                2265
            

            

                
            

            

                
                                let v48 = C::ty_int(ctx, v47);

            

        

            

                2266
            

            

                
            

            

                
                                if let Some(v49) = v48 {

            

        

            

                2267
            

            

                
            

            

                
                                    let v149 = C::unpack_value_array_2(ctx, v147);

            

        

            

                2268
            

            

                
            

            

                
                                    if v149.0 == v149.1 {

            

        

            

                2269
            

            

                
            

            

                
                                        let v168 = C::imm64(ctx, 0x1);

            

        

            

                2270
            

            

                
            

            

                
                                        let v212 = constructor_iconst(ctx, v49, v168);

            

        

            

                2271
            

            

                
            

            

                
                                        // Rule at src/opts/icmp.isle line 5.

            

        

            

                2272
            

            

                
            

            

                
                                        returns.push(v212);

            

        

            

                2273
            

            

                
            

            

                
                                    }

            

        

            

                2274
            

            

                
            

            

                
                                }

            

        

            

                2275
            

            

                
            

            

                
                            }

            

        

            

                2276
            

            

                
            

            

                
                            let v149 = C::unpack_value_array_2(ctx, v147);

            

        

            

                2277
            

            

                
            

            

                
                            let v152 = C::inst_data_etor(ctx, v149.0);

            

        

            

                2278
            

            

                
            

            

                
                            let mut v152 = v152;

            

        

            

                2279
            

            

                
            

            

                
                            while let Some(v153) = v152.next(ctx) {

            

        

            

                2280
            

            

                
            

            

                
                                if let &InstructionData::Unary {

            

        

            

                2281
            

            

                
            

            

                
                                    opcode: ref v156,

            

        

            

                2282
            

            

                
            

            

                
                                    arg: v157,

            

        

            

                2283
            

            

                
            

            

                
                                } = &v153.1

            

        

            

                2284
            

            

                
            

            

                
                                {

            

        

            

                2285
            

            

                
            

            

                
                                    if let &Opcode::Uextend = v156 {

            

        

            

                2286
            

            

                
            

            

                
                                        let v159 = C::inst_data_etor(ctx, v149.1);

            

        

            

                2287
            

            

                
            

            

                
                                        let mut v159 = v159;

            

        

            

                2288
            

            

                
            

            

                
                                        while let Some(v160) = v159.next(ctx) {

            

        

            

                2289
            

            

                
            

            

                
                                            if let &InstructionData::UnaryImm {

            

        

            

                2290
            

            

                
            

            

                
                                                opcode: ref v163,

            

        

            

                2291
            

            

                
            

            

                
                                                imm: v164,

            

        

            

                2292
            

            

                
            

            

                
                                            } = &v160.1

            

        

            

                2293
            

            

                
            

            

                
                                            {

            

        

            

                2294
            

            

                
            

            

                
                                                if let &Opcode::Iconst = v163 {

            

        

            

                2295
            

            

                
            

            

                
                                                    let v165 = C::u64_from_imm64(ctx, v164);

            

        

            

                2296
            

            

                
            

            

                
                                                    if v165 == 0x0 {

            

        

            

                2297
            

            

                
            

            

                
                                                        let v213 = C::inst_data_etor(ctx, v157);

            

        

            

                2298
            

            

                
            

            

                
                                                        let mut v213 = v213;

            

        

            

                2299
            

            

                
            

            

                
                                                        while let Some(v214) = v213.next(ctx) {

            

        

            

                2300
            

            

                
            

            

                
                                                            if let &InstructionData::IntCompare {

            

        

            

                2301
            

            

                
            

            

                
                                                                opcode: ref v217,

            

        

            

                2302
            

            

                
            

            

                
                                                                args: ref v218,

            

        

            

                2303
            

            

                
            

            

                
                                                                cond: ref v219,

            

        

            

                2304
            

            

                
            

            

                
                                                            } = &v214.1

            

        

            

                2305
            

            

                
            

            

                
                                                            {

            

        

            

                2306
            

            

                
            

            

                
                                                                if let &Opcode::Icmp = v217 {

            

        

            

                2307
            

            

                
            

            

                
                                                                    if v2.0 == v214.0 {

            

        

            

                2308
            

            

                
            

            

                
                                                                        let v224 =

            

        

            

                2309
            

            

                
            

            

                
                                                                            &C::intcc_inverse(

            

        

            

                2310
            

            

                
            

            

                
                                                                                ctx, v219,

            

        

            

                2311
            

            

                
            

            

                
                                                                            );

            

        

            

                2312
            

            

                
            

            

                
                                                                        let v220 =

            

        

            

                2313
            

            

                
            

            

                
                                                                            C::unpack_value_array_2(

            

        

            

                2314
            

            

                
            

            

                
                                                                                ctx, v218,

            

        

            

                2315
            

            

                
            

            

                
                                                                            );

            

        

            

                2316
            

            

                
            

            

                
                                                                        let v225 = constructor_icmp(

            

        

            

                2317
            

            

                
            

            

                
                                                                            ctx, v2.0, v224,

            

        

            

                2318
            

            

                
            

            

                
                                                                            v220.0, v220.1,

            

        

            

                2319
            

            

                
            

            

                
                                                                        );

            

        

            

                2320
            

            

                
            

            

                
                                                                        let v226 =

            

        

            

                2321
            

            

                
            

            

                
                                                                            C::subsume(ctx, v225);

            

        

            

                2322
            

            

                
            

            

                
                                                                        // Rule at src/opts/icmp.isle line 22.

            

        

            

                2323
            

            

                
            

            

                
                                                                        returns.push(v226);

            

        

            

                2324
            

            

                
            

            

                
                                                                    }

            

        

            

                2325
            

            

                
            

            

                
                                                                }

            

        

            

                2326
            

            

                
            

            

                
                                                            }

            

        

            

                2327
            

            

                
            

            

                
                                                        }

            

        

            

                2328
            

            

                
            

            

                
                                                    }

            

        

            

                2329
            

            

                
            

            

                
                                                }

            

        

            

                2330
            

            

                
            

            

                
                                            }

            

        

            

                2331
            

            

                
            

            

                
                                        }

            

        

            

                2332
            

            

                
            

            

                
                                    }

            

        

            

                2333
            

            

                
            

            

                
                                }

            

        

            

                2334
            

            

                
            

            

                
                            }

            

        

            

                2335
            

            

                
            

            

                
                        }

            

        

            

                2336
            

            

                
            

            

                
                        &IntCC::NotEqual => {

            

        

            

                2337
            

            

                
            

            

                
                            let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                2338
            

            

                
            

            

                
                            if let Some(v47) = v46 {

            

        

            

                2339
            

            

                
            

            

                
                                let v48 = C::ty_int(ctx, v47);

            

        

            

                2340
            

            

                
            

            

                
                                if let Some(v49) = v48 {

            

        

            

                2341
            

            

                
            

            

                
                                    let v149 = C::unpack_value_array_2(ctx, v147);

            

        

            

                2342
            

            

                
            

            

                
                                    if v149.0 == v149.1 {

            

        

            

                2343
            

            

                
            

            

                
                                        let v51 = C::imm64(ctx, 0x0);

            

        

            

                2344
            

            

                
            

            

                
                                        let v52 = constructor_iconst(ctx, v49, v51);

            

        

            

                2345
            

            

                
            

            

                
                                        // Rule at src/opts/icmp.isle line 6.

            

        

            

                2346
            

            

                
            

            

                
                                        returns.push(v52);

            

        

            

                2347
            

            

                
            

            

                
                                    }

            

        

            

                2348
            

            

                
            

            

                
                                }

            

        

            

                2349
            

            

                
            

            

                
                            }

            

        

            

                2350
            

            

                
            

            

                
                            let v149 = C::unpack_value_array_2(ctx, v147);

            

        

            

                2351
            

            

                
            

            

                
                            let v152 = C::inst_data_etor(ctx, v149.0);

            

        

            

                2352
            

            

                
            

            

                
                            let mut v152 = v152;

            

        

            

                2353
            

            

                
            

            

                
                            while let Some(v153) = v152.next(ctx) {

            

        

            

                2354
            

            

                
            

            

                
                                if let &InstructionData::Unary {

            

        

            

                2355
            

            

                
            

            

                
                                    opcode: ref v156,

            

        

            

                2356
            

            

                
            

            

                
                                    arg: v157,

            

        

            

                2357
            

            

                
            

            

                
                                } = &v153.1

            

        

            

                2358
            

            

                
            

            

                
                                {

            

        

            

                2359
            

            

                
            

            

                
                                    if let &Opcode::Uextend = v156 {

            

        

            

                2360
            

            

                
            

            

                
                                        let v159 = C::inst_data_etor(ctx, v149.1);

            

        

            

                2361
            

            

                
            

            

                
                                        let mut v159 = v159;

            

        

            

                2362
            

            

                
            

            

                
                                        while let Some(v160) = v159.next(ctx) {

            

        

            

                2363
            

            

                
            

            

                
                                            if let &InstructionData::UnaryImm {

            

        

            

                2364
            

            

                
            

            

                
                                                opcode: ref v163,

            

        

            

                2365
            

            

                
            

            

                
                                                imm: v164,

            

        

            

                2366
            

            

                
            

            

                
                                            } = &v160.1

            

        

            

                2367
            

            

                
            

            

                
                                            {

            

        

            

                2368
            

            

                
            

            

                
                                                if let &Opcode::Iconst = v163 {

            

        

            

                2369
            

            

                
            

            

                
                                                    let v165 = C::u64_from_imm64(ctx, v164);

            

        

            

                2370
            

            

                
            

            

                
                                                    if v165 == 0x0 {

            

        

            

                2371
            

            

                
            

            

                
                                                        let v213 = C::inst_data_etor(ctx, v157);

            

        

            

                2372
            

            

                
            

            

                
                                                        let mut v213 = v213;

            

        

            

                2373
            

            

                
            

            

                
                                                        while let Some(v214) = v213.next(ctx) {

            

        

            

                2374
            

            

                
            

            

                
                                                            if let &InstructionData::IntCompare {

            

        

            

                2375
            

            

                
            

            

                
                                                                opcode: ref v217,

            

        

            

                2376
            

            

                
            

            

                
                                                                args: ref v218,

            

        

            

                2377
            

            

                
            

            

                
                                                                cond: ref v219,

            

        

            

                2378
            

            

                
            

            

                
                                                            } = &v214.1

            

        

            

                2379
            

            

                
            

            

                
                                                            {

            

        

            

                2380
            

            

                
            

            

                
                                                                if let &Opcode::Icmp = v217 {

            

        

            

                2381
            

            

                
            

            

                
                                                                    if v2.0 == v214.0 {

            

        

            

                2382
            

            

                
            

            

                
                                                                        let v223 =

            

        

            

                2383
            

            

                
            

            

                
                                                                            C::subsume(ctx, v157);

            

        

            

                2384
            

            

                
            

            

                
                                                                        // Rule at src/opts/icmp.isle line 17.

            

        

            

                2385
            

            

                
            

            

                
                                                                        returns.push(v223);

            

        

            

                2386
            

            

                
            

            

                
                                                                    }

            

        

            

                2387
            

            

                
            

            

                
                                                                }

            

        

            

                2388
            

            

                
            

            

                
                                                            }

            

        

            

                2389
            

            

                
            

            

                
                                                        }

            

        

            

                2390
            

            

                
            

            

                
                                                    }

            

        

            

                2391
            

            

                
            

            

                
                                                }

            

        

            

                2392
            

            

                
            

            

                
                                            }

            

        

            

                2393
            

            

                
            

            

                
                                        }

            

        

            

                2394
            

            

                
            

            

                
                                    }

            

        

            

                2395
            

            

                
            

            

                
                                }

            

        

            

                2396
            

            

                
            

            

                
                            }

            

        

            

                2397
            

            

                
            

            

                
                        }

            

        

            

                2398
            

            

                
            

            

                
                        &IntCC::SignedGreaterThan => {

            

        

            

                2399
            

            

                
            

            

                
                            let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                2400
            

            

                
            

            

                
                            if let Some(v47) = v46 {

            

        

            

                2401
            

            

                
            

            

                
                                let v48 = C::ty_int(ctx, v47);

            

        

            

                2402
            

            

                
            

            

                
                                if let Some(v49) = v48 {

            

        

            

                2403
            

            

                
            

            

                
                                    let v149 = C::unpack_value_array_2(ctx, v147);

            

        

            

                2404
            

            

                
            

            

                
                                    let v159 = C::inst_data_etor(ctx, v149.1);

            

        

            

                2405
            

            

                
            

            

                
                                    let mut v159 = v159;

            

        

            

                2406
            

            

                
            

            

                
                                    while let Some(v160) = v159.next(ctx) {

            

        

            

                2407
            

            

                
            

            

                
                                        if let &InstructionData::UnaryImm {

            

        

            

                2408
            

            

                
            

            

                
                                            opcode: ref v163,

            

        

            

                2409
            

            

                
            

            

                
                                            imm: v164,

            

        

            

                2410
            

            

                
            

            

                
                                        } = &v160.1

            

        

            

                2411
            

            

                
            

            

                
                                        {

            

        

            

                2412
            

            

                
            

            

                
                                            if let &Opcode::Iconst = v163 {

            

        

            

                2413
            

            

                
            

            

                
                                                let v165 = C::u64_from_imm64(ctx, v164);

            

        

            

                2414
            

            

                
            

            

                
                                                let v261 = C::ty_smin(ctx, v160.0);

            

        

            

                2415
            

            

                
            

            

                
                                                let v262 = C::u64_eq(ctx, v165, v261);

            

        

            

                2416
            

            

                
            

            

                
                                                if v262 == true {

            

        

            

                2417
            

            

                
            

            

                
                                                    let v257 =

            

        

            

                2418
            

            

                
            

            

                
                                                        constructor_ne(ctx, v49, v149.0, v149.1);

            

        

            

                2419
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 98.

            

        

            

                2420
            

            

                
            

            

                
                                                    returns.push(v257);

            

        

            

                2421
            

            

                
            

            

                
                                                }

            

        

            

                2422
            

            

                
            

            

                
                                                let v263 = C::ty_smax(ctx, v160.0);

            

        

            

                2423
            

            

                
            

            

                
                                                let v264 = C::u64_eq(ctx, v165, v263);

            

        

            

                2424
            

            

                
            

            

                
                                                if v264 == true {

            

        

            

                2425
            

            

                
            

            

                
                                                    let v51 = C::imm64(ctx, 0x0);

            

        

            

                2426
            

            

                
            

            

                
                                                    let v52 = constructor_iconst(ctx, v49, v51);

            

        

            

                2427
            

            

                
            

            

                
                                                    let v53 = C::subsume(ctx, v52);

            

        

            

                2428
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 118.

            

        

            

                2429
            

            

                
            

            

                
                                                    returns.push(v53);

            

        

            

                2430
            

            

                
            

            

                
                                                }

            

        

            

                2431
            

            

                
            

            

                
                                            }

            

        

            

                2432
            

            

                
            

            

                
                                        }

            

        

            

                2433
            

            

                
            

            

                
                                    }

            

        

            

                2434
            

            

                
            

            

                
                                    if v149.0 == v149.1 {

            

        

            

                2435
            

            

                
            

            

                
                                        let v51 = C::imm64(ctx, 0x0);

            

        

            

                2436
            

            

                
            

            

                
                                        let v52 = constructor_iconst(ctx, v49, v51);

            

        

            

                2437
            

            

                
            

            

                
                                        // Rule at src/opts/icmp.isle line 9.

            

        

            

                2438
            

            

                
            

            

                
                                        returns.push(v52);

            

        

            

                2439
            

            

                
            

            

                
                                    }

            

        

            

                2440
            

            

                
            

            

                
                                }

            

        

            

                2441
            

            

                
            

            

                
                            }

            

        

            

                2442
            

            

                
            

            

                
                        }

            

        

            

                2443
            

            

                
            

            

                
                        &IntCC::SignedGreaterThanOrEqual => {

            

        

            

                2444
            

            

                
            

            

                
                            let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                2445
            

            

                
            

            

                
                            if let Some(v47) = v46 {

            

        

            

                2446
            

            

                
            

            

                
                                let v48 = C::ty_int(ctx, v47);

            

        

            

                2447
            

            

                
            

            

                
                                if let Some(v49) = v48 {

            

        

            

                2448
            

            

                
            

            

                
                                    let v149 = C::unpack_value_array_2(ctx, v147);

            

        

            

                2449
            

            

                
            

            

                
                                    let v159 = C::inst_data_etor(ctx, v149.1);

            

        

            

                2450
            

            

                
            

            

                
                                    let mut v159 = v159;

            

        

            

                2451
            

            

                
            

            

                
                                    while let Some(v160) = v159.next(ctx) {

            

        

            

                2452
            

            

                
            

            

                
                                        if let &InstructionData::UnaryImm {

            

        

            

                2453
            

            

                
            

            

                
                                            opcode: ref v163,

            

        

            

                2454
            

            

                
            

            

                
                                            imm: v164,

            

        

            

                2455
            

            

                
            

            

                
                                        } = &v160.1

            

        

            

                2456
            

            

                
            

            

                
                                        {

            

        

            

                2457
            

            

                
            

            

                
                                            if let &Opcode::Iconst = v163 {

            

        

            

                2458
            

            

                
            

            

                
                                                let v165 = C::u64_from_imm64(ctx, v164);

            

        

            

                2459
            

            

                
            

            

                
                                                let v261 = C::ty_smin(ctx, v160.0);

            

        

            

                2460
            

            

                
            

            

                
                                                let v262 = C::u64_eq(ctx, v165, v261);

            

        

            

                2461
            

            

                
            

            

                
                                                if v262 == true {

            

        

            

                2462
            

            

                
            

            

                
                                                    let v168 = C::imm64(ctx, 0x1);

            

        

            

                2463
            

            

                
            

            

                
                                                    let v212 = constructor_iconst(ctx, v49, v168);

            

        

            

                2464
            

            

                
            

            

                
                                                    let v258 = C::subsume(ctx, v212);

            

        

            

                2465
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 103.

            

        

            

                2466
            

            

                
            

            

                
                                                    returns.push(v258);

            

        

            

                2467
            

            

                
            

            

                
                                                }

            

        

            

                2468
            

            

                
            

            

                
                                                let v263 = C::ty_smax(ctx, v160.0);

            

        

            

                2469
            

            

                
            

            

                
                                                let v264 = C::u64_eq(ctx, v165, v263);

            

        

            

                2470
            

            

                
            

            

                
                                                if v264 == true {

            

        

            

                2471
            

            

                
            

            

                
                                                    let v256 =

            

        

            

                2472
            

            

                
            

            

                
                                                        constructor_eq(ctx, v49, v149.0, v149.1);

            

        

            

                2473
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 123.

            

        

            

                2474
            

            

                
            

            

                
                                                    returns.push(v256);

            

        

            

                2475
            

            

                
            

            

                
                                                }

            

        

            

                2476
            

            

                
            

            

                
                                            }

            

        

            

                2477
            

            

                
            

            

                
                                        }

            

        

            

                2478
            

            

                
            

            

                
                                    }

            

        

            

                2479
            

            

                
            

            

                
                                    if v149.0 == v149.1 {

            

        

            

                2480
            

            

                
            

            

                
                                        let v168 = C::imm64(ctx, 0x1);

            

        

            

                2481
            

            

                
            

            

                
                                        let v212 = constructor_iconst(ctx, v49, v168);

            

        

            

                2482
            

            

                
            

            

                
                                        // Rule at src/opts/icmp.isle line 10.

            

        

            

                2483
            

            

                
            

            

                
                                        returns.push(v212);

            

        

            

                2484
            

            

                
            

            

                
                                    }

            

        

            

                2485
            

            

                
            

            

                
                                }

            

        

            

                2486
            

            

                
            

            

                
                            }

            

        

            

                2487
            

            

                
            

            

                
                            let v149 = C::unpack_value_array_2(ctx, v147);

            

        

            

                2488
            

            

                
            

            

                
                            let v152 = C::inst_data_etor(ctx, v149.0);

            

        

            

                2489
            

            

                
            

            

                
                            let mut v152 = v152;

            

        

            

                2490
            

            

                
            

            

                
                            while let Some(v153) = v152.next(ctx) {

            

        

            

                2491
            

            

                
            

            

                
                                if v153.0 == I64 {

            

        

            

                2492
            

            

                
            

            

                
                                    if let &InstructionData::Unary {

            

        

            

                2493
            

            

                
            

            

                
                                        opcode: ref v156,

            

        

            

                2494
            

            

                
            

            

                
                                        arg: v157,

            

        

            

                2495
            

            

                
            

            

                
                                    } = &v153.1

            

        

            

                2496
            

            

                
            

            

                
                                    {

            

        

            

                2497
            

            

                
            

            

                
                                        if let &Opcode::Uextend = v156 {

            

        

            

                2498
            

            

                
            

            

                
                                            let v158 = C::value_type(ctx, v157);

            

        

            

                2499
            

            

                
            

            

                
                                            if v158 == I32 {

            

        

            

                2500
            

            

                
            

            

                
                                                let v159 = C::inst_data_etor(ctx, v149.1);

            

        

            

                2501
            

            

                
            

            

                
                                                let mut v159 = v159;

            

        

            

                2502
            

            

                
            

            

                
                                                while let Some(v160) = v159.next(ctx) {

            

        

            

                2503
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                2504
            

            

                
            

            

                
                                                        opcode: ref v163,

            

        

            

                2505
            

            

                
            

            

                
                                                        imm: v164,

            

        

            

                2506
            

            

                
            

            

                
                                                    } = &v160.1

            

        

            

                2507
            

            

                
            

            

                
                                                    {

            

        

            

                2508
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v163 {

            

        

            

                2509
            

            

                
            

            

                
                                                            let v165 = C::u64_from_imm64(ctx, v164);

            

        

            

                2510
            

            

                
            

            

                
                                                            if v165 == 0x0 {

            

        

            

                2511
            

            

                
            

            

                
                                                                let v168 = C::imm64(ctx, 0x1);

            

        

            

                2512
            

            

                
            

            

                
                                                                let v169 = constructor_iconst(

            

        

            

                2513
            

            

                
            

            

                
                                                                    ctx, v2.0, v168,

            

        

            

                2514
            

            

                
            

            

                
                                                                );

            

        

            

                2515
            

            

                
            

            

                
                                                                // Rule at src/opts/algebraic.isle line 336.

            

        

            

                2516
            

            

                
            

            

                
                                                                returns.push(v169);

            

        

            

                2517
            

            

                
            

            

                
                                                            }

            

        

            

                2518
            

            

                
            

            

                
                                                        }

            

        

            

                2519
            

            

                
            

            

                
                                                    }

            

        

            

                2520
            

            

                
            

            

                
                                                }

            

        

            

                2521
            

            

                
            

            

                
                                            }

            

        

            

                2522
            

            

                
            

            

                
                                        }

            

        

            

                2523
            

            

                
            

            

                
                                    }

            

        

            

                2524
            

            

                
            

            

                
                                }

            

        

            

                2525
            

            

                
            

            

                
                            }

            

        

            

                2526
            

            

                
            

            

                
                        }

            

        

            

                2527
            

            

                
            

            

                
                        &IntCC::SignedLessThan => {

            

        

            

                2528
            

            

                
            

            

                
                            let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                2529
            

            

                
            

            

                
                            if let Some(v47) = v46 {

            

        

            

                2530
            

            

                
            

            

                
                                let v48 = C::ty_int(ctx, v47);

            

        

            

                2531
            

            

                
            

            

                
                                if let Some(v49) = v48 {

            

        

            

                2532
            

            

                
            

            

                
                                    let v149 = C::unpack_value_array_2(ctx, v147);

            

        

            

                2533
            

            

                
            

            

                
                                    let v159 = C::inst_data_etor(ctx, v149.1);

            

        

            

                2534
            

            

                
            

            

                
                                    let mut v159 = v159;

            

        

            

                2535
            

            

                
            

            

                
                                    while let Some(v160) = v159.next(ctx) {

            

        

            

                2536
            

            

                
            

            

                
                                        if let &InstructionData::UnaryImm {

            

        

            

                2537
            

            

                
            

            

                
                                            opcode: ref v163,

            

        

            

                2538
            

            

                
            

            

                
                                            imm: v164,

            

        

            

                2539
            

            

                
            

            

                
                                        } = &v160.1

            

        

            

                2540
            

            

                
            

            

                
                                        {

            

        

            

                2541
            

            

                
            

            

                
                                            if let &Opcode::Iconst = v163 {

            

        

            

                2542
            

            

                
            

            

                
                                                let v165 = C::u64_from_imm64(ctx, v164);

            

        

            

                2543
            

            

                
            

            

                
                                                let v261 = C::ty_smin(ctx, v160.0);

            

        

            

                2544
            

            

                
            

            

                
                                                let v262 = C::u64_eq(ctx, v165, v261);

            

        

            

                2545
            

            

                
            

            

                
                                                if v262 == true {

            

        

            

                2546
            

            

                
            

            

                
                                                    let v51 = C::imm64(ctx, 0x0);

            

        

            

                2547
            

            

                
            

            

                
                                                    let v52 = constructor_iconst(ctx, v49, v51);

            

        

            

                2548
            

            

                
            

            

                
                                                    let v53 = C::subsume(ctx, v52);

            

        

            

                2549
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 88.

            

        

            

                2550
            

            

                
            

            

                
                                                    returns.push(v53);

            

        

            

                2551
            

            

                
            

            

                
                                                }

            

        

            

                2552
            

            

                
            

            

                
                                                let v263 = C::ty_smax(ctx, v160.0);

            

        

            

                2553
            

            

                
            

            

                
                                                let v264 = C::u64_eq(ctx, v165, v263);

            

        

            

                2554
            

            

                
            

            

                
                                                if v264 == true {

            

        

            

                2555
            

            

                
            

            

                
                                                    let v257 =

            

        

            

                2556
            

            

                
            

            

                
                                                        constructor_ne(ctx, v49, v149.0, v149.1);

            

        

            

                2557
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 108.

            

        

            

                2558
            

            

                
            

            

                
                                                    returns.push(v257);

            

        

            

                2559
            

            

                
            

            

                
                                                }

            

        

            

                2560
            

            

                
            

            

                
                                            }

            

        

            

                2561
            

            

                
            

            

                
                                        }

            

        

            

                2562
            

            

                
            

            

                
                                    }

            

        

            

                2563
            

            

                
            

            

                
                                    if v149.0 == v149.1 {

            

        

            

                2564
            

            

                
            

            

                
                                        let v51 = C::imm64(ctx, 0x0);

            

        

            

                2565
            

            

                
            

            

                
                                        let v52 = constructor_iconst(ctx, v49, v51);

            

        

            

                2566
            

            

                
            

            

                
                                        // Rule at src/opts/icmp.isle line 13.

            

        

            

                2567
            

            

                
            

            

                
                                        returns.push(v52);

            

        

            

                2568
            

            

                
            

            

                
                                    }

            

        

            

                2569
            

            

                
            

            

                
                                }

            

        

            

                2570
            

            

                
            

            

                
                            }

            

        

            

                2571
            

            

                
            

            

                
                            let v149 = C::unpack_value_array_2(ctx, v147);

            

        

            

                2572
            

            

                
            

            

                
                            let v152 = C::inst_data_etor(ctx, v149.0);

            

        

            

                2573
            

            

                
            

            

                
                            let mut v152 = v152;

            

        

            

                2574
            

            

                
            

            

                
                            while let Some(v153) = v152.next(ctx) {

            

        

            

                2575
            

            

                
            

            

                
                                if v153.0 == I64 {

            

        

            

                2576
            

            

                
            

            

                
                                    if let &InstructionData::Unary {

            

        

            

                2577
            

            

                
            

            

                
                                        opcode: ref v156,

            

        

            

                2578
            

            

                
            

            

                
                                        arg: v157,

            

        

            

                2579
            

            

                
            

            

                
                                    } = &v153.1

            

        

            

                2580
            

            

                
            

            

                
                                    {

            

        

            

                2581
            

            

                
            

            

                
                                        if let &Opcode::Uextend = v156 {

            

        

            

                2582
            

            

                
            

            

                
                                            let v158 = C::value_type(ctx, v157);

            

        

            

                2583
            

            

                
            

            

                
                                            if v158 == I32 {

            

        

            

                2584
            

            

                
            

            

                
                                                let v159 = C::inst_data_etor(ctx, v149.1);

            

        

            

                2585
            

            

                
            

            

                
                                                let mut v159 = v159;

            

        

            

                2586
            

            

                
            

            

                
                                                while let Some(v160) = v159.next(ctx) {

            

        

            

                2587
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                2588
            

            

                
            

            

                
                                                        opcode: ref v163,

            

        

            

                2589
            

            

                
            

            

                
                                                        imm: v164,

            

        

            

                2590
            

            

                
            

            

                
                                                    } = &v160.1

            

        

            

                2591
            

            

                
            

            

                
                                                    {

            

        

            

                2592
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v163 {

            

        

            

                2593
            

            

                
            

            

                
                                                            let v165 = C::u64_from_imm64(ctx, v164);

            

        

            

                2594
            

            

                
            

            

                
                                                            if v165 == 0x0 {

            

        

            

                2595
            

            

                
            

            

                
                                                                let v51 = C::imm64(ctx, 0x0);

            

        

            

                2596
            

            

                
            

            

                
                                                                let v166 = constructor_iconst(

            

        

            

                2597
            

            

                
            

            

                
                                                                    ctx, v2.0, v51,

            

        

            

                2598
            

            

                
            

            

                
                                                                );

            

        

            

                2599
            

            

                
            

            

                
                                                                // Rule at src/opts/algebraic.isle line 331.

            

        

            

                2600
            

            

                
            

            

                
                                                                returns.push(v166);

            

        

            

                2601
            

            

                
            

            

                
                                                            }

            

        

            

                2602
            

            

                
            

            

                
                                                        }

            

        

            

                2603
            

            

                
            

            

                
                                                    }

            

        

            

                2604
            

            

                
            

            

                
                                                }

            

        

            

                2605
            

            

                
            

            

                
                                            }

            

        

            

                2606
            

            

                
            

            

                
                                        }

            

        

            

                2607
            

            

                
            

            

                
                                    }

            

        

            

                2608
            

            

                
            

            

                
                                }

            

        

            

                2609
            

            

                
            

            

                
                            }

            

        

            

                2610
            

            

                
            

            

                
                        }

            

        

            

                2611
            

            

                
            

            

                
                        &IntCC::SignedLessThanOrEqual => {

            

        

            

                2612
            

            

                
            

            

                
                            let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                2613
            

            

                
            

            

                
                            if let Some(v47) = v46 {

            

        

            

                2614
            

            

                
            

            

                
                                let v48 = C::ty_int(ctx, v47);

            

        

            

                2615
            

            

                
            

            

                
                                if let Some(v49) = v48 {

            

        

            

                2616
            

            

                
            

            

                
                                    let v149 = C::unpack_value_array_2(ctx, v147);

            

        

            

                2617
            

            

                
            

            

                
                                    let v159 = C::inst_data_etor(ctx, v149.1);

            

        

            

                2618
            

            

                
            

            

                
                                    let mut v159 = v159;

            

        

            

                2619
            

            

                
            

            

                
                                    while let Some(v160) = v159.next(ctx) {

            

        

            

                2620
            

            

                
            

            

                
                                        if let &InstructionData::UnaryImm {

            

        

            

                2621
            

            

                
            

            

                
                                            opcode: ref v163,

            

        

            

                2622
            

            

                
            

            

                
                                            imm: v164,

            

        

            

                2623
            

            

                
            

            

                
                                        } = &v160.1

            

        

            

                2624
            

            

                
            

            

                
                                        {

            

        

            

                2625
            

            

                
            

            

                
                                            if let &Opcode::Iconst = v163 {

            

        

            

                2626
            

            

                
            

            

                
                                                let v165 = C::u64_from_imm64(ctx, v164);

            

        

            

                2627
            

            

                
            

            

                
                                                let v261 = C::ty_smin(ctx, v160.0);

            

        

            

                2628
            

            

                
            

            

                
                                                let v262 = C::u64_eq(ctx, v165, v261);

            

        

            

                2629
            

            

                
            

            

                
                                                if v262 == true {

            

        

            

                2630
            

            

                
            

            

                
                                                    let v256 =

            

        

            

                2631
            

            

                
            

            

                
                                                        constructor_eq(ctx, v49, v149.0, v149.1);

            

        

            

                2632
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 93.

            

        

            

                2633
            

            

                
            

            

                
                                                    returns.push(v256);

            

        

            

                2634
            

            

                
            

            

                
                                                }

            

        

            

                2635
            

            

                
            

            

                
                                                let v263 = C::ty_smax(ctx, v160.0);

            

        

            

                2636
            

            

                
            

            

                
                                                let v264 = C::u64_eq(ctx, v165, v263);

            

        

            

                2637
            

            

                
            

            

                
                                                if v264 == true {

            

        

            

                2638
            

            

                
            

            

                
                                                    let v168 = C::imm64(ctx, 0x1);

            

        

            

                2639
            

            

                
            

            

                
                                                    let v212 = constructor_iconst(ctx, v49, v168);

            

        

            

                2640
            

            

                
            

            

                
                                                    let v258 = C::subsume(ctx, v212);

            

        

            

                2641
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 113.

            

        

            

                2642
            

            

                
            

            

                
                                                    returns.push(v258);

            

        

            

                2643
            

            

                
            

            

                
                                                }

            

        

            

                2644
            

            

                
            

            

                
                                            }

            

        

            

                2645
            

            

                
            

            

                
                                        }

            

        

            

                2646
            

            

                
            

            

                
                                    }

            

        

            

                2647
            

            

                
            

            

                
                                    if v149.0 == v149.1 {

            

        

            

                2648
            

            

                
            

            

                
                                        let v168 = C::imm64(ctx, 0x1);

            

        

            

                2649
            

            

                
            

            

                
                                        let v212 = constructor_iconst(ctx, v49, v168);

            

        

            

                2650
            

            

                
            

            

                
                                        // Rule at src/opts/icmp.isle line 14.

            

        

            

                2651
            

            

                
            

            

                
                                        returns.push(v212);

            

        

            

                2652
            

            

                
            

            

                
                                    }

            

        

            

                2653
            

            

                
            

            

                
                                }

            

        

            

                2654
            

            

                
            

            

                
                            }

            

        

            

                2655
            

            

                
            

            

                
                        }

            

        

            

                2656
            

            

                
            

            

                
                        &IntCC::UnsignedGreaterThan => {

            

        

            

                2657
            

            

                
            

            

                
                            let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                2658
            

            

                
            

            

                
                            if let Some(v47) = v46 {

            

        

            

                2659
            

            

                
            

            

                
                                let v48 = C::ty_int(ctx, v47);

            

        

            

                2660
            

            

                
            

            

                
                                if let Some(v49) = v48 {

            

        

            

                2661
            

            

                
            

            

                
                                    let v149 = C::unpack_value_array_2(ctx, v147);

            

        

            

                2662
            

            

                
            

            

                
                                    let v159 = C::inst_data_etor(ctx, v149.1);

            

        

            

                2663
            

            

                
            

            

                
                                    let mut v159 = v159;

            

        

            

                2664
            

            

                
            

            

                
                                    while let Some(v160) = v159.next(ctx) {

            

        

            

                2665
            

            

                
            

            

                
                                        if let &InstructionData::UnaryImm {

            

        

            

                2666
            

            

                
            

            

                
                                            opcode: ref v163,

            

        

            

                2667
            

            

                
            

            

                
                                            imm: v164,

            

        

            

                2668
            

            

                
            

            

                
                                        } = &v160.1

            

        

            

                2669
            

            

                
            

            

                
                                        {

            

        

            

                2670
            

            

                
            

            

                
                                            if let &Opcode::Iconst = v163 {

            

        

            

                2671
            

            

                
            

            

                
                                                let v165 = C::u64_from_imm64(ctx, v164);

            

        

            

                2672
            

            

                
            

            

                
                                                if v165 == 0x0 {

            

        

            

                2673
            

            

                
            

            

                
                                                    let v257 =

            

        

            

                2674
            

            

                
            

            

                
                                                        constructor_ne(ctx, v49, v149.0, v149.1);

            

        

            

                2675
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 60.

            

        

            

                2676
            

            

                
            

            

                
                                                    returns.push(v257);

            

        

            

                2677
            

            

                
            

            

                
                                                }

            

        

            

                2678
            

            

                
            

            

                
                                                let v259 = C::ty_umax(ctx, v160.0);

            

        

            

                2679
            

            

                
            

            

                
                                                let v260 = C::u64_eq(ctx, v165, v259);

            

        

            

                2680
            

            

                
            

            

                
                                                if v260 == true {

            

        

            

                2681
            

            

                
            

            

                
                                                    let v51 = C::imm64(ctx, 0x0);

            

        

            

                2682
            

            

                
            

            

                
                                                    let v52 = constructor_iconst(ctx, v49, v51);

            

        

            

                2683
            

            

                
            

            

                
                                                    let v53 = C::subsume(ctx, v52);

            

        

            

                2684
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 78.

            

        

            

                2685
            

            

                
            

            

                
                                                    returns.push(v53);

            

        

            

                2686
            

            

                
            

            

                
                                                }

            

        

            

                2687
            

            

                
            

            

                
                                            }

            

        

            

                2688
            

            

                
            

            

                
                                        }

            

        

            

                2689
            

            

                
            

            

                
                                    }

            

        

            

                2690
            

            

                
            

            

                
                                    if v149.0 == v149.1 {

            

        

            

                2691
            

            

                
            

            

                
                                        let v51 = C::imm64(ctx, 0x0);

            

        

            

                2692
            

            

                
            

            

                
                                        let v52 = constructor_iconst(ctx, v49, v51);

            

        

            

                2693
            

            

                
            

            

                
                                        // Rule at src/opts/icmp.isle line 7.

            

        

            

                2694
            

            

                
            

            

                
                                        returns.push(v52);

            

        

            

                2695
            

            

                
            

            

                
                                    }

            

        

            

                2696
            

            

                
            

            

                
                                }

            

        

            

                2697
            

            

                
            

            

                
                            }

            

        

            

                2698
            

            

                
            

            

                
                        }

            

        

            

                2699
            

            

                
            

            

                
                        &IntCC::UnsignedGreaterThanOrEqual => {

            

        

            

                2700
            

            

                
            

            

                
                            let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                2701
            

            

                
            

            

                
                            if let Some(v47) = v46 {

            

        

            

                2702
            

            

                
            

            

                
                                let v48 = C::ty_int(ctx, v47);

            

        

            

                2703
            

            

                
            

            

                
                                if let Some(v49) = v48 {

            

        

            

                2704
            

            

                
            

            

                
                                    let v149 = C::unpack_value_array_2(ctx, v147);

            

        

            

                2705
            

            

                
            

            

                
                                    let v159 = C::inst_data_etor(ctx, v149.1);

            

        

            

                2706
            

            

                
            

            

                
                                    let mut v159 = v159;

            

        

            

                2707
            

            

                
            

            

                
                                    while let Some(v160) = v159.next(ctx) {

            

        

            

                2708
            

            

                
            

            

                
                                        if let &InstructionData::UnaryImm {

            

        

            

                2709
            

            

                
            

            

                
                                            opcode: ref v163,

            

        

            

                2710
            

            

                
            

            

                
                                            imm: v164,

            

        

            

                2711
            

            

                
            

            

                
                                        } = &v160.1

            

        

            

                2712
            

            

                
            

            

                
                                        {

            

        

            

                2713
            

            

                
            

            

                
                                            if let &Opcode::Iconst = v163 {

            

        

            

                2714
            

            

                
            

            

                
                                                let v165 = C::u64_from_imm64(ctx, v164);

            

        

            

                2715
            

            

                
            

            

                
                                                if v165 == 0x0 {

            

        

            

                2716
            

            

                
            

            

                
                                                    let v168 = C::imm64(ctx, 0x1);

            

        

            

                2717
            

            

                
            

            

                
                                                    let v212 = constructor_iconst(ctx, v49, v168);

            

        

            

                2718
            

            

                
            

            

                
                                                    let v258 = C::subsume(ctx, v212);

            

        

            

                2719
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 64.

            

        

            

                2720
            

            

                
            

            

                
                                                    returns.push(v258);

            

        

            

                2721
            

            

                
            

            

                
                                                }

            

        

            

                2722
            

            

                
            

            

                
                                                let v259 = C::ty_umax(ctx, v160.0);

            

        

            

                2723
            

            

                
            

            

                
                                                let v260 = C::u64_eq(ctx, v165, v259);

            

        

            

                2724
            

            

                
            

            

                
                                                if v260 == true {

            

        

            

                2725
            

            

                
            

            

                
                                                    let v256 =

            

        

            

                2726
            

            

                
            

            

                
                                                        constructor_eq(ctx, v49, v149.0, v149.1);

            

        

            

                2727
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 83.

            

        

            

                2728
            

            

                
            

            

                
                                                    returns.push(v256);

            

        

            

                2729
            

            

                
            

            

                
                                                }

            

        

            

                2730
            

            

                
            

            

                
                                            }

            

        

            

                2731
            

            

                
            

            

                
                                        }

            

        

            

                2732
            

            

                
            

            

                
                                    }

            

        

            

                2733
            

            

                
            

            

                
                                    if v149.0 == v149.1 {

            

        

            

                2734
            

            

                
            

            

                
                                        let v168 = C::imm64(ctx, 0x1);

            

        

            

                2735
            

            

                
            

            

                
                                        let v212 = constructor_iconst(ctx, v49, v168);

            

        

            

                2736
            

            

                
            

            

                
                                        // Rule at src/opts/icmp.isle line 8.

            

        

            

                2737
            

            

                
            

            

                
                                        returns.push(v212);

            

        

            

                2738
            

            

                
            

            

                
                                    }

            

        

            

                2739
            

            

                
            

            

                
                                }

            

        

            

                2740
            

            

                
            

            

                
                            }

            

        

            

                2741
            

            

                
            

            

                
                        }

            

        

            

                2742
            

            

                
            

            

                
                        &IntCC::UnsignedLessThan => {

            

        

            

                2743
            

            

                
            

            

                
                            let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                2744
            

            

                
            

            

                
                            if let Some(v47) = v46 {

            

        

            

                2745
            

            

                
            

            

                
                                let v48 = C::ty_int(ctx, v47);

            

        

            

                2746
            

            

                
            

            

                
                                if let Some(v49) = v48 {

            

        

            

                2747
            

            

                
            

            

                
                                    let v149 = C::unpack_value_array_2(ctx, v147);

            

        

            

                2748
            

            

                
            

            

                
                                    let v159 = C::inst_data_etor(ctx, v149.1);

            

        

            

                2749
            

            

                
            

            

                
                                    let mut v159 = v159;

            

        

            

                2750
            

            

                
            

            

                
                                    while let Some(v160) = v159.next(ctx) {

            

        

            

                2751
            

            

                
            

            

                
                                        if let &InstructionData::UnaryImm {

            

        

            

                2752
            

            

                
            

            

                
                                            opcode: ref v163,

            

        

            

                2753
            

            

                
            

            

                
                                            imm: v164,

            

        

            

                2754
            

            

                
            

            

                
                                        } = &v160.1

            

        

            

                2755
            

            

                
            

            

                
                                        {

            

        

            

                2756
            

            

                
            

            

                
                                            if let &Opcode::Iconst = v163 {

            

        

            

                2757
            

            

                
            

            

                
                                                let v165 = C::u64_from_imm64(ctx, v164);

            

        

            

                2758
            

            

                
            

            

                
                                                if v165 == 0x0 {

            

        

            

                2759
            

            

                
            

            

                
                                                    let v51 = C::imm64(ctx, 0x0);

            

        

            

                2760
            

            

                
            

            

                
                                                    let v52 = constructor_iconst(ctx, v49, v51);

            

        

            

                2761
            

            

                
            

            

                
                                                    let v53 = C::subsume(ctx, v52);

            

        

            

                2762
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 52.

            

        

            

                2763
            

            

                
            

            

                
                                                    returns.push(v53);

            

        

            

                2764
            

            

                
            

            

                
                                                }

            

        

            

                2765
            

            

                
            

            

                
                                                let v259 = C::ty_umax(ctx, v160.0);

            

        

            

                2766
            

            

                
            

            

                
                                                let v260 = C::u64_eq(ctx, v165, v259);

            

        

            

                2767
            

            

                
            

            

                
                                                if v260 == true {

            

        

            

                2768
            

            

                
            

            

                
                                                    let v257 =

            

        

            

                2769
            

            

                
            

            

                
                                                        constructor_ne(ctx, v49, v149.0, v149.1);

            

        

            

                2770
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 68.

            

        

            

                2771
            

            

                
            

            

                
                                                    returns.push(v257);

            

        

            

                2772
            

            

                
            

            

                
                                                }

            

        

            

                2773
            

            

                
            

            

                
                                            }

            

        

            

                2774
            

            

                
            

            

                
                                        }

            

        

            

                2775
            

            

                
            

            

                
                                    }

            

        

            

                2776
            

            

                
            

            

                
                                    if v149.0 == v149.1 {

            

        

            

                2777
            

            

                
            

            

                
                                        let v51 = C::imm64(ctx, 0x0);

            

        

            

                2778
            

            

                
            

            

                
                                        let v52 = constructor_iconst(ctx, v49, v51);

            

        

            

                2779
            

            

                
            

            

                
                                        // Rule at src/opts/icmp.isle line 11.

            

        

            

                2780
            

            

                
            

            

                
                                        returns.push(v52);

            

        

            

                2781
            

            

                
            

            

                
                                    }

            

        

            

                2782
            

            

                
            

            

                
                                }

            

        

            

                2783
            

            

                
            

            

                
                            }

            

        

            

                2784
            

            

                
            

            

                
                        }

            

        

            

                2785
            

            

                
            

            

                
                        &IntCC::UnsignedLessThanOrEqual => {

            

        

            

                2786
            

            

                
            

            

                
                            let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                2787
            

            

                
            

            

                
                            if let Some(v47) = v46 {

            

        

            

                2788
            

            

                
            

            

                
                                let v48 = C::ty_int(ctx, v47);

            

        

            

                2789
            

            

                
            

            

                
                                if let Some(v49) = v48 {

            

        

            

                2790
            

            

                
            

            

                
                                    let v149 = C::unpack_value_array_2(ctx, v147);

            

        

            

                2791
            

            

                
            

            

                
                                    let v159 = C::inst_data_etor(ctx, v149.1);

            

        

            

                2792
            

            

                
            

            

                
                                    let mut v159 = v159;

            

        

            

                2793
            

            

                
            

            

                
                                    while let Some(v160) = v159.next(ctx) {

            

        

            

                2794
            

            

                
            

            

                
                                        if let &InstructionData::UnaryImm {

            

        

            

                2795
            

            

                
            

            

                
                                            opcode: ref v163,

            

        

            

                2796
            

            

                
            

            

                
                                            imm: v164,

            

        

            

                2797
            

            

                
            

            

                
                                        } = &v160.1

            

        

            

                2798
            

            

                
            

            

                
                                        {

            

        

            

                2799
            

            

                
            

            

                
                                            if let &Opcode::Iconst = v163 {

            

        

            

                2800
            

            

                
            

            

                
                                                let v165 = C::u64_from_imm64(ctx, v164);

            

        

            

                2801
            

            

                
            

            

                
                                                if v165 == 0x0 {

            

        

            

                2802
            

            

                
            

            

                
                                                    let v256 =

            

        

            

                2803
            

            

                
            

            

                
                                                        constructor_eq(ctx, v49, v149.0, v149.1);

            

        

            

                2804
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 56.

            

        

            

                2805
            

            

                
            

            

                
                                                    returns.push(v256);

            

        

            

                2806
            

            

                
            

            

                
                                                }

            

        

            

                2807
            

            

                
            

            

                
                                                let v259 = C::ty_umax(ctx, v160.0);

            

        

            

                2808
            

            

                
            

            

                
                                                let v260 = C::u64_eq(ctx, v165, v259);

            

        

            

                2809
            

            

                
            

            

                
                                                if v260 == true {

            

        

            

                2810
            

            

                
            

            

                
                                                    let v168 = C::imm64(ctx, 0x1);

            

        

            

                2811
            

            

                
            

            

                
                                                    let v212 = constructor_iconst(ctx, v49, v168);

            

        

            

                2812
            

            

                
            

            

                
                                                    let v258 = C::subsume(ctx, v212);

            

        

            

                2813
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 73.

            

        

            

                2814
            

            

                
            

            

                
                                                    returns.push(v258);

            

        

            

                2815
            

            

                
            

            

                
                                                }

            

        

            

                2816
            

            

                
            

            

                
                                            }

            

        

            

                2817
            

            

                
            

            

                
                                        }

            

        

            

                2818
            

            

                
            

            

                
                                    }

            

        

            

                2819
            

            

                
            

            

                
                                    if v149.0 == v149.1 {

            

        

            

                2820
            

            

                
            

            

                
                                        let v168 = C::imm64(ctx, 0x1);

            

        

            

                2821
            

            

                
            

            

                
                                        let v212 = constructor_iconst(ctx, v49, v168);

            

        

            

                2822
            

            

                
            

            

                
                                        // Rule at src/opts/icmp.isle line 12.

            

        

            

                2823
            

            

                
            

            

                
                                        returns.push(v212);

            

        

            

                2824
            

            

                
            

            

                
                                    }

            

        

            

                2825
            

            

                
            

            

                
                                }

            

        

            

                2826
            

            

                
            

            

                
                            }

            

        

            

                2827
            

            

                
            

            

                
                        }

            

        

            

                2828
            

            

                
            

            

                
                        _ => {}

            

        

            

                2829
            

            

                
            

            

                
                    }

            

        

            

                2830
            

            

                
            

            

                
                    let v149 = C::unpack_value_array_2(ctx, v147);

            

        

            

                2831
            

            

                
            

            

                
                    let v152 = C::inst_data_etor(ctx, v149.0);

            

        

            

                2832
            

            

                
            

            

                
                    let mut v152 = v152;

            

        

            

                2833
            

            

                
            

            

                
                    while let Some(v153) = v152.next(ctx) {

            

        

            

                2834
            

            

                
            

            

                
                        if let &InstructionData::UnaryImm {

            

        

            

                2835
            

            

                
            

            

                
                            opcode: ref v338,

            

        

            

                2836
            

            

                
            

            

                
                            imm: v339,

            

        

            

                2837
            

            

                
            

            

                
                        } = &v153.1

            

        

            

                2838
            

            

                
            

            

                
                        {

            

        

            

                2839
            

            

                
            

            

                
                            if let &Opcode::Iconst = v338 {

            

        

            

                2840
            

            

                
            

            

                
                                let v159 = C::inst_data_etor(ctx, v149.1);

            

        

            

                2841
            

            

                
            

            

                
                                let mut v159 = v159;

            

        

            

                2842
            

            

                
            

            

                
                                while let Some(v160) = v159.next(ctx) {

            

        

            

                2843
            

            

                
            

            

                
                                    if let &InstructionData::UnaryImm {

            

        

            

                2844
            

            

                
            

            

                
                                        opcode: ref v163,

            

        

            

                2845
            

            

                
            

            

                
                                        imm: v164,

            

        

            

                2846
            

            

                
            

            

                
                                    } = &v160.1

            

        

            

                2847
            

            

                
            

            

                
                                    {

            

        

            

                2848
            

            

                
            

            

                
                                        if let &Opcode::Iconst = v163 {

            

        

            

                2849
            

            

                
            

            

                
                                            if v153.0 == v160.0 {

            

        

            

                2850
            

            

                
            

            

                
                                                let v340 =

            

        

            

                2851
            

            

                
            

            

                
                                                    C::imm64_icmp(ctx, v153.0, v148, v339, v164);

            

        

            

                2852
            

            

                
            

            

                
                                                let v341 = constructor_iconst(ctx, v2.0, v340);

            

        

            

                2853
            

            

                
            

            

                
                                                let v342 = C::subsume(ctx, v341);

            

        

            

                2854
            

            

                
            

            

                
                                                // Rule at src/opts/cprop.isle line 79.

            

        

            

                2855
            

            

                
            

            

                
                                                returns.push(v342);

            

        

            

                2856
            

            

                
            

            

                
                                            }

            

        

            

                2857
            

            

                
            

            

                
                                        }

            

        

            

                2858
            

            

                
            

            

                
                                    }

            

        

            

                2859
            

            

                
            

            

                
                                }

            

        

            

                2860
            

            

                
            

            

                
                                let v350 = &C::intcc_reverse(ctx, v148);

            

        

            

                2861
            

            

                
            

            

                
                                let v351 = constructor_icmp(ctx, v2.0, v350, v149.1, v149.0);

            

        

            

                2862
            

            

                
            

            

                
                                // Rule at src/opts/cprop.isle line 113.

            

        

            

                2863
            

            

                
            

            

                
                                returns.push(v351);

            

        

            

                2864
            

            

                
            

            

                
                            }

            

        

            

                2865
            

            

                
            

            

                
                        }

            

        

            

                2866
            

            

                
            

            

                
                    }

            

        

            

                2867
            

            

                
            

            

                
                }

            

        

            

                2868
            

            

                
            

            

                
            }

            

        

            

                2869
            

            

                
            

            

                
            &InstructionData::Ternary {

            

        

            

                2870
            

            

                
            

            

                
                opcode: ref v170,

            

        

            

                2871
            

            

                
            

            

                
                args: ref v171,

            

        

            

                2872
            

            

                
            

            

                
            } => {

            

        

            

                2873
            

            

                
            

            

                
                match v170 {

            

        

            

                2874
            

            

                
            

            

                
                    &Opcode::Select => {

            

        

            

                2875
            

            

                
            

            

                
                        let v172 = C::unpack_value_array_3(ctx, v171);

            

        

            

                2876
            

            

                
            

            

                
                        let v176 = C::inst_data_etor(ctx, v172.0);

            

        

            

                2877
            

            

                
            

            

                
                        let mut v176 = v176;

            

        

            

                2878
            

            

                
            

            

                
                        while let Some(v177) = v176.next(ctx) {

            

        

            

                2879
            

            

                
            

            

                
                            match &v177.1 {

            

        

            

                2880
            

            

                
            

            

                
                                &InstructionData::FloatCompare {

            

        

            

                2881
            

            

                
            

            

                
                                    opcode: ref v194,

            

        

            

                2882
            

            

                
            

            

                
                                    args: ref v195,

            

        

            

                2883
            

            

                
            

            

                
                                    cond: ref v196,

            

        

            

                2884
            

            

                
            

            

                
                                } => {

            

        

            

                2885
            

            

                
            

            

                
                                    if let &Opcode::Fcmp = v194 {

            

        

            

                2886
            

            

                
            

            

                
                                        match v196 {

            

        

            

                2887
            

            

                
            

            

                
                                            &FloatCC::GreaterThan => {

            

        

            

                2888
            

            

                
            

            

                
                                                let v197 = C::unpack_value_array_2(ctx, v195);

            

        

            

                2889
            

            

                
            

            

                
                                                if v172.1 == v197.0 {

            

        

            

                2890
            

            

                
            

            

                
                                                    if v172.2 == v197.1 {

            

        

            

                2891
            

            

                
            

            

                
                                                        let v201 = constructor_fmax_pseudo(

            

        

            

                2892
            

            

                
            

            

                
                                                            ctx, v2.0, v197.0, v197.1,

            

        

            

                2893
            

            

                
            

            

                
                                                        );

            

        

            

                2894
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 392.

            

        

            

                2895
            

            

                
            

            

                
                                                        returns.push(v201);

            

        

            

                2896
            

            

                
            

            

                
                                                    }

            

        

            

                2897
            

            

                
            

            

                
                                                }

            

        

            

                2898
            

            

                
            

            

                
                                            }

            

        

            

                2899
            

            

                
            

            

                
                                            &FloatCC::LessThan => {

            

        

            

                2900
            

            

                
            

            

                
                                                let v197 = C::unpack_value_array_2(ctx, v195);

            

        

            

                2901
            

            

                
            

            

                
                                                if v172.1 == v197.0 {

            

        

            

                2902
            

            

                
            

            

                
                                                    if v172.2 == v197.1 {

            

        

            

                2903
            

            

                
            

            

                
                                                        let v200 = constructor_fmin_pseudo(

            

        

            

                2904
            

            

                
            

            

                
                                                            ctx, v2.0, v197.0, v197.1,

            

        

            

                2905
            

            

                
            

            

                
                                                        );

            

        

            

                2906
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 389.

            

        

            

                2907
            

            

                
            

            

                
                                                        returns.push(v200);

            

        

            

                2908
            

            

                
            

            

                
                                                    }

            

        

            

                2909
            

            

                
            

            

                
                                                }

            

        

            

                2910
            

            

                
            

            

                
                                            }

            

        

            

                2911
            

            

                
            

            

                
                                            _ => {}

            

        

            

                2912
            

            

                
            

            

                
                                        }

            

        

            

                2913
            

            

                
            

            

                
                                    }

            

        

            

                2914
            

            

                
            

            

                
                                }

            

        

            

                2915
            

            

                
            

            

                
                                &InstructionData::IntCompare {

            

        

            

                2916
            

            

                
            

            

                
                                    opcode: ref v180,

            

        

            

                2917
            

            

                
            

            

                
                                    args: ref v181,

            

        

            

                2918
            

            

                
            

            

                
                                    cond: ref v182,

            

        

            

                2919
            

            

                
            

            

                
                                } => {

            

        

            

                2920
            

            

                
            

            

                
                                    if let &Opcode::Icmp = v180 {

            

        

            

                2921
            

            

                
            

            

                
                                        match v182 {

            

        

            

                2922
            

            

                
            

            

                
                                            &IntCC::SignedGreaterThan => {

            

        

            

                2923
            

            

                
            

            

                
                                                let v183 = C::unpack_value_array_2(ctx, v181);

            

        

            

                2924
            

            

                
            

            

                
                                                if v172.1 == v183.0 {

            

        

            

                2925
            

            

                
            

            

                
                                                    if v172.2 == v183.1 {

            

        

            

                2926
            

            

                
            

            

                
                                                        let v186 = constructor_smax(

            

        

            

                2927
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                2928
            

            

                
            

            

                
                                                        );

            

        

            

                2929
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 343.

            

        

            

                2930
            

            

                
            

            

                
                                                        returns.push(v186);

            

        

            

                2931
            

            

                
            

            

                
                                                    }

            

        

            

                2932
            

            

                
            

            

                
                                                }

            

        

            

                2933
            

            

                
            

            

                
                                                if v172.1 == v183.1 {

            

        

            

                2934
            

            

                
            

            

                
                                                    if v172.2 == v183.0 {

            

        

            

                2935
            

            

                
            

            

                
                                                        let v188 = constructor_smin(

            

        

            

                2936
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                2937
            

            

                
            

            

                
                                                        );

            

        

            

                2938
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 357.

            

        

            

                2939
            

            

                
            

            

                
                                                        returns.push(v188);

            

        

            

                2940
            

            

                
            

            

                
                                                    }

            

        

            

                2941
            

            

                
            

            

                
                                                }

            

        

            

                2942
            

            

                
            

            

                
                                            }

            

        

            

                2943
            

            

                
            

            

                
                                            &IntCC::SignedGreaterThanOrEqual => {

            

        

            

                2944
            

            

                
            

            

                
                                                let v183 = C::unpack_value_array_2(ctx, v181);

            

        

            

                2945
            

            

                
            

            

                
                                                if v172.1 == v183.0 {

            

        

            

                2946
            

            

                
            

            

                
                                                    if v172.2 == v183.1 {

            

        

            

                2947
            

            

                
            

            

                
                                                        let v186 = constructor_smax(

            

        

            

                2948
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                2949
            

            

                
            

            

                
                                                        );

            

        

            

                2950
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 344.

            

        

            

                2951
            

            

                
            

            

                
                                                        returns.push(v186);

            

        

            

                2952
            

            

                
            

            

                
                                                    }

            

        

            

                2953
            

            

                
            

            

                
                                                }

            

        

            

                2954
            

            

                
            

            

                
                                                if v172.1 == v183.1 {

            

        

            

                2955
            

            

                
            

            

                
                                                    if v172.2 == v183.0 {

            

        

            

                2956
            

            

                
            

            

                
                                                        let v188 = constructor_smin(

            

        

            

                2957
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                2958
            

            

                
            

            

                
                                                        );

            

        

            

                2959
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 358.

            

        

            

                2960
            

            

                
            

            

                
                                                        returns.push(v188);

            

        

            

                2961
            

            

                
            

            

                
                                                    }

            

        

            

                2962
            

            

                
            

            

                
                                                }

            

        

            

                2963
            

            

                
            

            

                
                                            }

            

        

            

                2964
            

            

                
            

            

                
                                            &IntCC::SignedLessThan => {

            

        

            

                2965
            

            

                
            

            

                
                                                let v183 = C::unpack_value_array_2(ctx, v181);

            

        

            

                2966
            

            

                
            

            

                
                                                if v172.1 == v183.0 {

            

        

            

                2967
            

            

                
            

            

                
                                                    if v172.2 == v183.1 {

            

        

            

                2968
            

            

                
            

            

                
                                                        let v188 = constructor_smin(

            

        

            

                2969
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                2970
            

            

                
            

            

                
                                                        );

            

        

            

                2971
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 347.

            

        

            

                2972
            

            

                
            

            

                
                                                        returns.push(v188);

            

        

            

                2973
            

            

                
            

            

                
                                                    }

            

        

            

                2974
            

            

                
            

            

                
                                                }

            

        

            

                2975
            

            

                
            

            

                
                                                if v172.1 == v183.1 {

            

        

            

                2976
            

            

                
            

            

                
                                                    if v172.2 == v183.0 {

            

        

            

                2977
            

            

                
            

            

                
                                                        let v186 = constructor_smax(

            

        

            

                2978
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                2979
            

            

                
            

            

                
                                                        );

            

        

            

                2980
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 353.

            

        

            

                2981
            

            

                
            

            

                
                                                        returns.push(v186);

            

        

            

                2982
            

            

                
            

            

                
                                                    }

            

        

            

                2983
            

            

                
            

            

                
                                                }

            

        

            

                2984
            

            

                
            

            

                
                                            }

            

        

            

                2985
            

            

                
            

            

                
                                            &IntCC::SignedLessThanOrEqual => {

            

        

            

                2986
            

            

                
            

            

                
                                                let v183 = C::unpack_value_array_2(ctx, v181);

            

        

            

                2987
            

            

                
            

            

                
                                                if v172.1 == v183.0 {

            

        

            

                2988
            

            

                
            

            

                
                                                    if v172.2 == v183.1 {

            

        

            

                2989
            

            

                
            

            

                
                                                        let v188 = constructor_smin(

            

        

            

                2990
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                2991
            

            

                
            

            

                
                                                        );

            

        

            

                2992
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 348.

            

        

            

                2993
            

            

                
            

            

                
                                                        returns.push(v188);

            

        

            

                2994
            

            

                
            

            

                
                                                    }

            

        

            

                2995
            

            

                
            

            

                
                                                }

            

        

            

                2996
            

            

                
            

            

                
                                                if v172.1 == v183.1 {

            

        

            

                2997
            

            

                
            

            

                
                                                    if v172.2 == v183.0 {

            

        

            

                2998
            

            

                
            

            

                
                                                        let v186 = constructor_smax(

            

        

            

                2999
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3000
            

            

                
            

            

                
                                                        );

            

        

            

                3001
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 354.

            

        

            

                3002
            

            

                
            

            

                
                                                        returns.push(v186);

            

        

            

                3003
            

            

                
            

            

                
                                                    }

            

        

            

                3004
            

            

                
            

            

                
                                                }

            

        

            

                3005
            

            

                
            

            

                
                                            }

            

        

            

                3006
            

            

                
            

            

                
                                            &IntCC::UnsignedGreaterThan => {

            

        

            

                3007
            

            

                
            

            

                
                                                let v183 = C::unpack_value_array_2(ctx, v181);

            

        

            

                3008
            

            

                
            

            

                
                                                if v172.1 == v183.0 {

            

        

            

                3009
            

            

                
            

            

                
                                                    if v172.2 == v183.1 {

            

        

            

                3010
            

            

                
            

            

                
                                                        let v187 = constructor_umax(

            

        

            

                3011
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3012
            

            

                
            

            

                
                                                        );

            

        

            

                3013
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 345.

            

        

            

                3014
            

            

                
            

            

                
                                                        returns.push(v187);

            

        

            

                3015
            

            

                
            

            

                
                                                    }

            

        

            

                3016
            

            

                
            

            

                
                                                }

            

        

            

                3017
            

            

                
            

            

                
                                                if v172.1 == v183.1 {

            

        

            

                3018
            

            

                
            

            

                
                                                    if v172.2 == v183.0 {

            

        

            

                3019
            

            

                
            

            

                
                                                        let v189 = constructor_umin(

            

        

            

                3020
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3021
            

            

                
            

            

                
                                                        );

            

        

            

                3022
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 359.

            

        

            

                3023
            

            

                
            

            

                
                                                        returns.push(v189);

            

        

            

                3024
            

            

                
            

            

                
                                                    }

            

        

            

                3025
            

            

                
            

            

                
                                                }

            

        

            

                3026
            

            

                
            

            

                
                                            }

            

        

            

                3027
            

            

                
            

            

                
                                            &IntCC::UnsignedGreaterThanOrEqual => {

            

        

            

                3028
            

            

                
            

            

                
                                                let v183 = C::unpack_value_array_2(ctx, v181);

            

        

            

                3029
            

            

                
            

            

                
                                                if v172.1 == v183.0 {

            

        

            

                3030
            

            

                
            

            

                
                                                    if v172.2 == v183.1 {

            

        

            

                3031
            

            

                
            

            

                
                                                        let v187 = constructor_umax(

            

        

            

                3032
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3033
            

            

                
            

            

                
                                                        );

            

        

            

                3034
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 346.

            

        

            

                3035
            

            

                
            

            

                
                                                        returns.push(v187);

            

        

            

                3036
            

            

                
            

            

                
                                                    }

            

        

            

                3037
            

            

                
            

            

                
                                                }

            

        

            

                3038
            

            

                
            

            

                
                                                if v172.1 == v183.1 {

            

        

            

                3039
            

            

                
            

            

                
                                                    if v172.2 == v183.0 {

            

        

            

                3040
            

            

                
            

            

                
                                                        let v189 = constructor_umin(

            

        

            

                3041
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3042
            

            

                
            

            

                
                                                        );

            

        

            

                3043
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 360.

            

        

            

                3044
            

            

                
            

            

                
                                                        returns.push(v189);

            

        

            

                3045
            

            

                
            

            

                
                                                    }

            

        

            

                3046
            

            

                
            

            

                
                                                }

            

        

            

                3047
            

            

                
            

            

                
                                            }

            

        

            

                3048
            

            

                
            

            

                
                                            &IntCC::UnsignedLessThan => {

            

        

            

                3049
            

            

                
            

            

                
                                                let v183 = C::unpack_value_array_2(ctx, v181);

            

        

            

                3050
            

            

                
            

            

                
                                                if v172.1 == v183.0 {

            

        

            

                3051
            

            

                
            

            

                
                                                    if v172.2 == v183.1 {

            

        

            

                3052
            

            

                
            

            

                
                                                        let v189 = constructor_umin(

            

        

            

                3053
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3054
            

            

                
            

            

                
                                                        );

            

        

            

                3055
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 349.

            

        

            

                3056
            

            

                
            

            

                
                                                        returns.push(v189);

            

        

            

                3057
            

            

                
            

            

                
                                                    }

            

        

            

                3058
            

            

                
            

            

                
                                                }

            

        

            

                3059
            

            

                
            

            

                
                                                if v172.1 == v183.1 {

            

        

            

                3060
            

            

                
            

            

                
                                                    if v172.2 == v183.0 {

            

        

            

                3061
            

            

                
            

            

                
                                                        let v187 = constructor_umax(

            

        

            

                3062
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3063
            

            

                
            

            

                
                                                        );

            

        

            

                3064
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 355.

            

        

            

                3065
            

            

                
            

            

                
                                                        returns.push(v187);

            

        

            

                3066
            

            

                
            

            

                
                                                    }

            

        

            

                3067
            

            

                
            

            

                
                                                }

            

        

            

                3068
            

            

                
            

            

                
                                            }

            

        

            

                3069
            

            

                
            

            

                
                                            &IntCC::UnsignedLessThanOrEqual => {

            

        

            

                3070
            

            

                
            

            

                
                                                let v183 = C::unpack_value_array_2(ctx, v181);

            

        

            

                3071
            

            

                
            

            

                
                                                if v172.1 == v183.0 {

            

        

            

                3072
            

            

                
            

            

                
                                                    if v172.2 == v183.1 {

            

        

            

                3073
            

            

                
            

            

                
                                                        let v189 = constructor_umin(

            

        

            

                3074
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3075
            

            

                
            

            

                
                                                        );

            

        

            

                3076
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 350.

            

        

            

                3077
            

            

                
            

            

                
                                                        returns.push(v189);

            

        

            

                3078
            

            

                
            

            

                
                                                    }

            

        

            

                3079
            

            

                
            

            

                
                                                }

            

        

            

                3080
            

            

                
            

            

                
                                                if v172.1 == v183.1 {

            

        

            

                3081
            

            

                
            

            

                
                                                    if v172.2 == v183.0 {

            

        

            

                3082
            

            

                
            

            

                
                                                        let v187 = constructor_umax(

            

        

            

                3083
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3084
            

            

                
            

            

                
                                                        );

            

        

            

                3085
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 356.

            

        

            

                3086
            

            

                
            

            

                
                                                        returns.push(v187);

            

        

            

                3087
            

            

                
            

            

                
                                                    }

            

        

            

                3088
            

            

                
            

            

                
                                                }

            

        

            

                3089
            

            

                
            

            

                
                                            }

            

        

            

                3090
            

            

                
            

            

                
                                            _ => {}

            

        

            

                3091
            

            

                
            

            

                
                                        }

            

        

            

                3092
            

            

                
            

            

                
                                    }

            

        

            

                3093
            

            

                
            

            

                
                                }

            

        

            

                3094
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                3095
            

            

                
            

            

                
                                    opcode: ref v202,

            

        

            

                3096
            

            

                
            

            

                
                                    arg: v203,

            

        

            

                3097
            

            

                
            

            

                
                                } => {

            

        

            

                3098
            

            

                
            

            

                
                                    if let &Opcode::Uextend = v202 {

            

        

            

                3099
            

            

                
            

            

                
                                        let v227 = C::inst_data_etor(ctx, v203);

            

        

            

                3100
            

            

                
            

            

                
                                        let mut v227 = v227;

            

        

            

                3101
            

            

                
            

            

                
                                        while let Some(v228) = v227.next(ctx) {

            

        

            

                3102
            

            

                
            

            

                
                                            if let &InstructionData::IntCompare {

            

        

            

                3103
            

            

                
            

            

                
                                                opcode: ref v231,

            

        

            

                3104
            

            

                
            

            

                
                                                args: ref v232,

            

        

            

                3105
            

            

                
            

            

                
                                                cond: ref v233,

            

        

            

                3106
            

            

                
            

            

                
                                            } = &v228.1

            

        

            

                3107
            

            

                
            

            

                
                                            {

            

        

            

                3108
            

            

                
            

            

                
                                                if let &Opcode::Icmp = v231 {

            

        

            

                3109
            

            

                
            

            

                
                                                    let v237 = constructor_select(

            

        

            

                3110
            

            

                
            

            

                
                                                        ctx, v2.0, v203, v172.1, v172.2,

            

        

            

                3111
            

            

                
            

            

                
                                                    );

            

        

            

                3112
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 29.

            

        

            

                3113
            

            

                
            

            

                
                                                    returns.push(v237);

            

        

            

                3114
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 32.

            

        

            

                3115
            

            

                
            

            

                
                                                    returns.push(v237);

            

        

            

                3116
            

            

                
            

            

                
                                                }

            

        

            

                3117
            

            

                
            

            

                
                                            }

            

        

            

                3118
            

            

                
            

            

                
                                        }

            

        

            

                3119
            

            

                
            

            

                
                                    }

            

        

            

                3120
            

            

                
            

            

                
                                }

            

        

            

                3121
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                3122
            

            

                
            

            

                
                                    opcode: ref v382,

            

        

            

                3123
            

            

                
            

            

                
                                    imm: v383,

            

        

            

                3124
            

            

                
            

            

                
                                } => {

            

        

            

                3125
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v382 {

            

        

            

                3126
            

            

                
            

            

                
                                        let v384 = C::u64_from_imm64(ctx, v383);

            

        

            

                3127
            

            

                
            

            

                
                                        if v384 == 0x0 {

            

        

            

                3128
            

            

                
            

            

                
                                            // Rule at src/opts/cprop.isle line 169.

            

        

            

                3129
            

            

                
            

            

                
                                            returns.push(v172.2);

            

        

            

                3130
            

            

                
            

            

                
                                        }

            

        

            

                3131
            

            

                
            

            

                
                                        let v385 = C::u64_is_zero(ctx, v384);

            

        

            

                3132
            

            

                
            

            

                
                                        if v385 == false {

            

        

            

                3133
            

            

                
            

            

                
                                            // Rule at src/opts/cprop.isle line 166.

            

        

            

                3134
            

            

                
            

            

                
                                            returns.push(v172.1);

            

        

            

                3135
            

            

                
            

            

                
                                        }

            

        

            

                3136
            

            

                
            

            

                
                                    }

            

        

            

                3137
            

            

                
            

            

                
                                }

            

        

            

                3138
            

            

                
            

            

                
                                _ => {}

            

        

            

                3139
            

            

                
            

            

                
                            }

            

        

            

                3140
            

            

                
            

            

                
                        }

            

        

            

                3141
            

            

                
            

            

                
                    }

            

        

            

                3142
            

            

                
            

            

                
                    &Opcode::Bitselect => {

            

        

            

                3143
            

            

                
            

            

                
                        let v190 = C::multi_lane(ctx, v2.0);

            

        

            

                3144
            

            

                
            

            

                
                        if let Some(v191) = v190 {

            

        

            

                3145
            

            

                
            

            

                
                            let v172 = C::unpack_value_array_3(ctx, v171);

            

        

            

                3146
            

            

                
            

            

                
                            let v176 = C::inst_data_etor(ctx, v172.0);

            

        

            

                3147
            

            

                
            

            

                
                            let mut v176 = v176;

            

        

            

                3148
            

            

                
            

            

                
                            while let Some(v177) = v176.next(ctx) {

            

        

            

                3149
            

            

                
            

            

                
                                if let &InstructionData::IntCompare {

            

        

            

                3150
            

            

                
            

            

                
                                    opcode: ref v180,

            

        

            

                3151
            

            

                
            

            

                
                                    args: ref v181,

            

        

            

                3152
            

            

                
            

            

                
                                    cond: ref v182,

            

        

            

                3153
            

            

                
            

            

                
                                } = &v177.1

            

        

            

                3154
            

            

                
            

            

                
                                {

            

        

            

                3155
            

            

                
            

            

                
                                    if let &Opcode::Icmp = v180 {

            

        

            

                3156
            

            

                
            

            

                
                                        match v182 {

            

        

            

                3157
            

            

                
            

            

                
                                            &IntCC::SignedGreaterThan => {

            

        

            

                3158
            

            

                
            

            

                
                                                let v183 = C::unpack_value_array_2(ctx, v181);

            

        

            

                3159
            

            

                
            

            

                
                                                if v172.1 == v183.0 {

            

        

            

                3160
            

            

                
            

            

                
                                                    if v172.2 == v183.1 {

            

        

            

                3161
            

            

                
            

            

                
                                                        let v186 = constructor_smax(

            

        

            

                3162
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3163
            

            

                
            

            

                
                                                        );

            

        

            

                3164
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 363.

            

        

            

                3165
            

            

                
            

            

                
                                                        returns.push(v186);

            

        

            

                3166
            

            

                
            

            

                
                                                    }

            

        

            

                3167
            

            

                
            

            

                
                                                }

            

        

            

                3168
            

            

                
            

            

                
                                                if v172.1 == v183.1 {

            

        

            

                3169
            

            

                
            

            

                
                                                    if v172.2 == v183.0 {

            

        

            

                3170
            

            

                
            

            

                
                                                        let v188 = constructor_smin(

            

        

            

                3171
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3172
            

            

                
            

            

                
                                                        );

            

        

            

                3173
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 377.

            

        

            

                3174
            

            

                
            

            

                
                                                        returns.push(v188);

            

        

            

                3175
            

            

                
            

            

                
                                                    }

            

        

            

                3176
            

            

                
            

            

                
                                                }

            

        

            

                3177
            

            

                
            

            

                
                                            }

            

        

            

                3178
            

            

                
            

            

                
                                            &IntCC::SignedGreaterThanOrEqual => {

            

        

            

                3179
            

            

                
            

            

                
                                                let v183 = C::unpack_value_array_2(ctx, v181);

            

        

            

                3180
            

            

                
            

            

                
                                                if v172.1 == v183.0 {

            

        

            

                3181
            

            

                
            

            

                
                                                    if v172.2 == v183.1 {

            

        

            

                3182
            

            

                
            

            

                
                                                        let v186 = constructor_smax(

            

        

            

                3183
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3184
            

            

                
            

            

                
                                                        );

            

        

            

                3185
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 364.

            

        

            

                3186
            

            

                
            

            

                
                                                        returns.push(v186);

            

        

            

                3187
            

            

                
            

            

                
                                                    }

            

        

            

                3188
            

            

                
            

            

                
                                                }

            

        

            

                3189
            

            

                
            

            

                
                                                if v172.1 == v183.1 {

            

        

            

                3190
            

            

                
            

            

                
                                                    if v172.2 == v183.0 {

            

        

            

                3191
            

            

                
            

            

                
                                                        let v188 = constructor_smin(

            

        

            

                3192
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3193
            

            

                
            

            

                
                                                        );

            

        

            

                3194
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 378.

            

        

            

                3195
            

            

                
            

            

                
                                                        returns.push(v188);

            

        

            

                3196
            

            

                
            

            

                
                                                    }

            

        

            

                3197
            

            

                
            

            

                
                                                }

            

        

            

                3198
            

            

                
            

            

                
                                            }

            

        

            

                3199
            

            

                
            

            

                
                                            &IntCC::SignedLessThan => {

            

        

            

                3200
            

            

                
            

            

                
                                                let v183 = C::unpack_value_array_2(ctx, v181);

            

        

            

                3201
            

            

                
            

            

                
                                                if v172.1 == v183.0 {

            

        

            

                3202
            

            

                
            

            

                
                                                    if v172.2 == v183.1 {

            

        

            

                3203
            

            

                
            

            

                
                                                        let v188 = constructor_smin(

            

        

            

                3204
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3205
            

            

                
            

            

                
                                                        );

            

        

            

                3206
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 367.

            

        

            

                3207
            

            

                
            

            

                
                                                        returns.push(v188);

            

        

            

                3208
            

            

                
            

            

                
                                                    }

            

        

            

                3209
            

            

                
            

            

                
                                                }

            

        

            

                3210
            

            

                
            

            

                
                                                if v172.1 == v183.1 {

            

        

            

                3211
            

            

                
            

            

                
                                                    if v172.2 == v183.0 {

            

        

            

                3212
            

            

                
            

            

                
                                                        let v186 = constructor_smax(

            

        

            

                3213
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3214
            

            

                
            

            

                
                                                        );

            

        

            

                3215
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 373.

            

        

            

                3216
            

            

                
            

            

                
                                                        returns.push(v186);

            

        

            

                3217
            

            

                
            

            

                
                                                    }

            

        

            

                3218
            

            

                
            

            

                
                                                }

            

        

            

                3219
            

            

                
            

            

                
                                            }

            

        

            

                3220
            

            

                
            

            

                
                                            &IntCC::SignedLessThanOrEqual => {

            

        

            

                3221
            

            

                
            

            

                
                                                let v183 = C::unpack_value_array_2(ctx, v181);

            

        

            

                3222
            

            

                
            

            

                
                                                if v172.1 == v183.0 {

            

        

            

                3223
            

            

                
            

            

                
                                                    if v172.2 == v183.1 {

            

        

            

                3224
            

            

                
            

            

                
                                                        let v188 = constructor_smin(

            

        

            

                3225
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3226
            

            

                
            

            

                
                                                        );

            

        

            

                3227
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 368.

            

        

            

                3228
            

            

                
            

            

                
                                                        returns.push(v188);

            

        

            

                3229
            

            

                
            

            

                
                                                    }

            

        

            

                3230
            

            

                
            

            

                
                                                }

            

        

            

                3231
            

            

                
            

            

                
                                                if v172.1 == v183.1 {

            

        

            

                3232
            

            

                
            

            

                
                                                    if v172.2 == v183.0 {

            

        

            

                3233
            

            

                
            

            

                
                                                        let v186 = constructor_smax(

            

        

            

                3234
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3235
            

            

                
            

            

                
                                                        );

            

        

            

                3236
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 374.

            

        

            

                3237
            

            

                
            

            

                
                                                        returns.push(v186);

            

        

            

                3238
            

            

                
            

            

                
                                                    }

            

        

            

                3239
            

            

                
            

            

                
                                                }

            

        

            

                3240
            

            

                
            

            

                
                                            }

            

        

            

                3241
            

            

                
            

            

                
                                            &IntCC::UnsignedGreaterThan => {

            

        

            

                3242
            

            

                
            

            

                
                                                let v183 = C::unpack_value_array_2(ctx, v181);

            

        

            

                3243
            

            

                
            

            

                
                                                if v172.1 == v183.0 {

            

        

            

                3244
            

            

                
            

            

                
                                                    if v172.2 == v183.1 {

            

        

            

                3245
            

            

                
            

            

                
                                                        let v187 = constructor_umax(

            

        

            

                3246
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3247
            

            

                
            

            

                
                                                        );

            

        

            

                3248
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 365.

            

        

            

                3249
            

            

                
            

            

                
                                                        returns.push(v187);

            

        

            

                3250
            

            

                
            

            

                
                                                    }

            

        

            

                3251
            

            

                
            

            

                
                                                }

            

        

            

                3252
            

            

                
            

            

                
                                                if v172.1 == v183.1 {

            

        

            

                3253
            

            

                
            

            

                
                                                    if v172.2 == v183.0 {

            

        

            

                3254
            

            

                
            

            

                
                                                        let v189 = constructor_umin(

            

        

            

                3255
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3256
            

            

                
            

            

                
                                                        );

            

        

            

                3257
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 379.

            

        

            

                3258
            

            

                
            

            

                
                                                        returns.push(v189);

            

        

            

                3259
            

            

                
            

            

                
                                                    }

            

        

            

                3260
            

            

                
            

            

                
                                                }

            

        

            

                3261
            

            

                
            

            

                
                                            }

            

        

            

                3262
            

            

                
            

            

                
                                            &IntCC::UnsignedGreaterThanOrEqual => {

            

        

            

                3263
            

            

                
            

            

                
                                                let v183 = C::unpack_value_array_2(ctx, v181);

            

        

            

                3264
            

            

                
            

            

                
                                                if v172.1 == v183.0 {

            

        

            

                3265
            

            

                
            

            

                
                                                    if v172.2 == v183.1 {

            

        

            

                3266
            

            

                
            

            

                
                                                        let v187 = constructor_umax(

            

        

            

                3267
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3268
            

            

                
            

            

                
                                                        );

            

        

            

                3269
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 366.

            

        

            

                3270
            

            

                
            

            

                
                                                        returns.push(v187);

            

        

            

                3271
            

            

                
            

            

                
                                                    }

            

        

            

                3272
            

            

                
            

            

                
                                                }

            

        

            

                3273
            

            

                
            

            

                
                                                if v172.1 == v183.1 {

            

        

            

                3274
            

            

                
            

            

                
                                                    if v172.2 == v183.0 {

            

        

            

                3275
            

            

                
            

            

                
                                                        let v189 = constructor_umin(

            

        

            

                3276
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3277
            

            

                
            

            

                
                                                        );

            

        

            

                3278
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 380.

            

        

            

                3279
            

            

                
            

            

                
                                                        returns.push(v189);

            

        

            

                3280
            

            

                
            

            

                
                                                    }

            

        

            

                3281
            

            

                
            

            

                
                                                }

            

        

            

                3282
            

            

                
            

            

                
                                            }

            

        

            

                3283
            

            

                
            

            

                
                                            &IntCC::UnsignedLessThan => {

            

        

            

                3284
            

            

                
            

            

                
                                                let v183 = C::unpack_value_array_2(ctx, v181);

            

        

            

                3285
            

            

                
            

            

                
                                                if v172.1 == v183.0 {

            

        

            

                3286
            

            

                
            

            

                
                                                    if v172.2 == v183.1 {

            

        

            

                3287
            

            

                
            

            

                
                                                        let v189 = constructor_umin(

            

        

            

                3288
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3289
            

            

                
            

            

                
                                                        );

            

        

            

                3290
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 369.

            

        

            

                3291
            

            

                
            

            

                
                                                        returns.push(v189);

            

        

            

                3292
            

            

                
            

            

                
                                                    }

            

        

            

                3293
            

            

                
            

            

                
                                                }

            

        

            

                3294
            

            

                
            

            

                
                                                if v172.1 == v183.1 {

            

        

            

                3295
            

            

                
            

            

                
                                                    if v172.2 == v183.0 {

            

        

            

                3296
            

            

                
            

            

                
                                                        let v187 = constructor_umax(

            

        

            

                3297
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3298
            

            

                
            

            

                
                                                        );

            

        

            

                3299
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 375.

            

        

            

                3300
            

            

                
            

            

                
                                                        returns.push(v187);

            

        

            

                3301
            

            

                
            

            

                
                                                    }

            

        

            

                3302
            

            

                
            

            

                
                                                }

            

        

            

                3303
            

            

                
            

            

                
                                            }

            

        

            

                3304
            

            

                
            

            

                
                                            &IntCC::UnsignedLessThanOrEqual => {

            

        

            

                3305
            

            

                
            

            

                
                                                let v183 = C::unpack_value_array_2(ctx, v181);

            

        

            

                3306
            

            

                
            

            

                
                                                if v172.1 == v183.0 {

            

        

            

                3307
            

            

                
            

            

                
                                                    if v172.2 == v183.1 {

            

        

            

                3308
            

            

                
            

            

                
                                                        let v189 = constructor_umin(

            

        

            

                3309
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3310
            

            

                
            

            

                
                                                        );

            

        

            

                3311
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 370.

            

        

            

                3312
            

            

                
            

            

                
                                                        returns.push(v189);

            

        

            

                3313
            

            

                
            

            

                
                                                    }

            

        

            

                3314
            

            

                
            

            

                
                                                }

            

        

            

                3315
            

            

                
            

            

                
                                                if v172.1 == v183.1 {

            

        

            

                3316
            

            

                
            

            

                
                                                    if v172.2 == v183.0 {

            

        

            

                3317
            

            

                
            

            

                
                                                        let v187 = constructor_umax(

            

        

            

                3318
            

            

                
            

            

                
                                                            ctx, v2.0, v183.0, v183.1,

            

        

            

                3319
            

            

                
            

            

                
                                                        );

            

        

            

                3320
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 376.

            

        

            

                3321
            

            

                
            

            

                
                                                        returns.push(v187);

            

        

            

                3322
            

            

                
            

            

                
                                                    }

            

        

            

                3323
            

            

                
            

            

                
                                                }

            

        

            

                3324
            

            

                
            

            

                
                                            }

            

        

            

                3325
            

            

                
            

            

                
                                            _ => {}

            

        

            

                3326
            

            

                
            

            

                
                                        }

            

        

            

                3327
            

            

                
            

            

                
                                    }

            

        

            

                3328
            

            

                
            

            

                
                                }

            

        

            

                3329
            

            

                
            

            

                
                            }

            

        

            

                3330
            

            

                
            

            

                
                        }

            

        

            

                3331
            

            

                
            

            

                
                    }

            

        

            

                3332
            

            

                
            

            

                
                    &Opcode::Fma => {

            

        

            

                3333
            

            

                
            

            

                
                        let v172 = C::unpack_value_array_3(ctx, v171);

            

        

            

                3334
            

            

                
            

            

                
                        let v176 = C::inst_data_etor(ctx, v172.0);

            

        

            

                3335
            

            

                
            

            

                
                        let mut v176 = v176;

            

        

            

                3336
            

            

                
            

            

                
                        while let Some(v177) = v176.next(ctx) {

            

        

            

                3337
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                3338
            

            

                
            

            

                
                                opcode: ref v202,

            

        

            

                3339
            

            

                
            

            

                
                                arg: v203,

            

        

            

                3340
            

            

                
            

            

                
                            } = &v177.1

            

        

            

                3341
            

            

                
            

            

                
                            {

            

        

            

                3342
            

            

                
            

            

                
                                if let &Opcode::Fneg = v202 {

            

        

            

                3343
            

            

                
            

            

                
                                    if v2.0 == v177.0 {

            

        

            

                3344
            

            

                
            

            

                
                                        let v204 = C::inst_data_etor(ctx, v172.1);

            

        

            

                3345
            

            

                
            

            

                
                                        let mut v204 = v204;

            

        

            

                3346
            

            

                
            

            

                
                                        while let Some(v205) = v204.next(ctx) {

            

        

            

                3347
            

            

                
            

            

                
                                            if let &InstructionData::Unary {

            

        

            

                3348
            

            

                
            

            

                
                                                opcode: ref v208,

            

        

            

                3349
            

            

                
            

            

                
                                                arg: v209,

            

        

            

                3350
            

            

                
            

            

                
                                            } = &v205.1

            

        

            

                3351
            

            

                
            

            

                
                                            {

            

        

            

                3352
            

            

                
            

            

                
                                                if let &Opcode::Fneg = v208 {

            

        

            

                3353
            

            

                
            

            

                
                                                    if v2.0 == v205.0 {

            

        

            

                3354
            

            

                
            

            

                
                                                        let v210 = constructor_fma(

            

        

            

                3355
            

            

                
            

            

                
                                                            ctx, v2.0, v203, v209, v172.2,

            

        

            

                3356
            

            

                
            

            

                
                                                        );

            

        

            

                3357
            

            

                
            

            

                
                                                        // Rule at src/opts/algebraic.isle line 405.

            

        

            

                3358
            

            

                
            

            

                
                                                        returns.push(v210);

            

        

            

                3359
            

            

                
            

            

                
                                                    }

            

        

            

                3360
            

            

                
            

            

                
                                                }

            

        

            

                3361
            

            

                
            

            

                
                                            }

            

        

            

                3362
            

            

                
            

            

                
                                        }

            

        

            

                3363
            

            

                
            

            

                
                                    }

            

        

            

                3364
            

            

                
            

            

                
                                }

            

        

            

                3365
            

            

                
            

            

                
                            }

            

        

            

                3366
            

            

                
            

            

                
                        }

            

        

            

                3367
            

            

                
            

            

                
                    }

            

        

            

                3368
            

            

                
            

            

                
                    _ => {}

            

        

            

                3369
            

            

                
            

            

                
                }

            

        

            

                3370
            

            

                
            

            

                
            }

            

        

            

                3371
            

            

                
            

            

                
            &InstructionData::Unary {

            

        

            

                3372
            

            

                
            

            

                
                opcode: ref v5,

            

        

            

                3373
            

            

                
            

            

                
                arg: v6,

            

        

            

                3374
            

            

                
            

            

                
            } => {

            

        

            

                3375
            

            

                
            

            

                
                match v5 {

            

        

            

                3376
            

            

                
            

            

                
                    &Opcode::Ineg => {

            

        

            

                3377
            

            

                
            

            

                
                        let v7 = C::inst_data_etor(ctx, v6);

            

        

            

                3378
            

            

                
            

            

                
                        let mut v7 = v7;

            

        

            

                3379
            

            

                
            

            

                
                        while let Some(v8) = v7.next(ctx) {

            

        

            

                3380
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                3381
            

            

                
            

            

                
                                opcode: ref v11,

            

        

            

                3382
            

            

                
            

            

                
                                arg: v12,

            

        

            

                3383
            

            

                
            

            

                
                            } = &v8.1

            

        

            

                3384
            

            

                
            

            

                
                            {

            

        

            

                3385
            

            

                
            

            

                
                                if let &Opcode::Ineg = v11 {

            

        

            

                3386
            

            

                
            

            

                
                                    if v2.0 == v8.0 {

            

        

            

                3387
            

            

                
            

            

                
                                        let v37 = C::subsume(ctx, v12);

            

        

            

                3388
            

            

                
            

            

                
                                        // Rule at src/opts/algebraic.isle line 36.

            

        

            

                3389
            

            

                
            

            

                
                                        returns.push(v37);

            

        

            

                3390
            

            

                
            

            

                
                                    }

            

        

            

                3391
            

            

                
            

            

                
                                }

            

        

            

                3392
            

            

                
            

            

                
                            }

            

        

            

                3393
            

            

                
            

            

                
                        }

            

        

            

                3394
            

            

                
            

            

                
                    }

            

        

            

                3395
            

            

                
            

            

                
                    &Opcode::Iabs => {

            

        

            

                3396
            

            

                
            

            

                
                        let v7 = C::inst_data_etor(ctx, v6);

            

        

            

                3397
            

            

                
            

            

                
                        let mut v7 = v7;

            

        

            

                3398
            

            

                
            

            

                
                        while let Some(v8) = v7.next(ctx) {

            

        

            

                3399
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                3400
            

            

                
            

            

                
                                opcode: ref v11,

            

        

            

                3401
            

            

                
            

            

                
                                arg: v12,

            

        

            

                3402
            

            

                
            

            

                
                            } = &v8.1

            

        

            

                3403
            

            

                
            

            

                
                            {

            

        

            

                3404
            

            

                
            

            

                
                                match v11 {

            

        

            

                3405
            

            

                
            

            

                
                                    &Opcode::Ineg => {

            

        

            

                3406
            

            

                
            

            

                
                                        if v2.0 == v8.0 {

            

        

            

                3407
            

            

                
            

            

                
                                            let v44 = constructor_iabs(ctx, v2.0, v12);

            

        

            

                3408
            

            

                
            

            

                
                                            // Rule at src/opts/algebraic.isle line 43.

            

        

            

                3409
            

            

                
            

            

                
                                            returns.push(v44);

            

        

            

                3410
            

            

                
            

            

                
                                        }

            

        

            

                3411
            

            

                
            

            

                
                                    }

            

        

            

                3412
            

            

                
            

            

                
                                    &Opcode::Iabs => {

            

        

            

                3413
            

            

                
            

            

                
                                        if v2.0 == v8.0 {

            

        

            

                3414
            

            

                
            

            

                
                                            let v45 = C::subsume(ctx, v6);

            

        

            

                3415
            

            

                
            

            

                
                                            // Rule at src/opts/algebraic.isle line 47.

            

        

            

                3416
            

            

                
            

            

                
                                            returns.push(v45);

            

        

            

                3417
            

            

                
            

            

                
                                        }

            

        

            

                3418
            

            

                
            

            

                
                                    }

            

        

            

                3419
            

            

                
            

            

                
                                    _ => {}

            

        

            

                3420
            

            

                
            

            

                
                                }

            

        

            

                3421
            

            

                
            

            

                
                            }

            

        

            

                3422
            

            

                
            

            

                
                        }

            

        

            

                3423
            

            

                
            

            

                
                    }

            

        

            

                3424
            

            

                
            

            

                
                    &Opcode::Bnot => {

            

        

            

                3425
            

            

                
            

            

                
                        let v7 = C::inst_data_etor(ctx, v6);

            

        

            

                3426
            

            

                
            

            

                
                        let mut v7 = v7;

            

        

            

                3427
            

            

                
            

            

                
                        while let Some(v8) = v7.next(ctx) {

            

        

            

                3428
            

            

                
            

            

                
                            match &v8.1 {

            

        

            

                3429
            

            

                
            

            

                
                                &InstructionData::Binary {

            

        

            

                3430
            

            

                
            

            

                
                                    opcode: ref v61,

            

        

            

                3431
            

            

                
            

            

                
                                    args: ref v62,

            

        

            

                3432
            

            

                
            

            

                
                                } => {

            

        

            

                3433
            

            

                
            

            

                
                                    match v61 {

            

        

            

                3434
            

            

                
            

            

                
                                        &Opcode::Band => {

            

        

            

                3435
            

            

                
            

            

                
                                            let v63 = C::unpack_value_array_2(ctx, v62);

            

        

            

                3436
            

            

                
            

            

                
                                            let v66 = constructor_bnot(ctx, v2.0, v63.0);

            

        

            

                3437
            

            

                
            

            

                
                                            let v67 = constructor_bnot(ctx, v2.0, v63.1);

            

        

            

                3438
            

            

                
            

            

                
                                            let v69 = constructor_bor(ctx, v2.0, v66, v67);

            

        

            

                3439
            

            

                
            

            

                
                                            // Rule at src/opts/algebraic.isle line 170.

            

        

            

                3440
            

            

                
            

            

                
                                            returns.push(v69);

            

        

            

                3441
            

            

                
            

            

                
                                        }

            

        

            

                3442
            

            

                
            

            

                
                                        &Opcode::Bor => {

            

        

            

                3443
            

            

                
            

            

                
                                            if v2.0 == v8.0 {

            

        

            

                3444
            

            

                
            

            

                
                                                let v63 = C::unpack_value_array_2(ctx, v62);

            

        

            

                3445
            

            

                
            

            

                
                                                let v66 = constructor_bnot(ctx, v2.0, v63.0);

            

        

            

                3446
            

            

                
            

            

                
                                                let v67 = constructor_bnot(ctx, v2.0, v63.1);

            

        

            

                3447
            

            

                
            

            

                
                                                let v68 = constructor_band(ctx, v2.0, v66, v67);

            

        

            

                3448
            

            

                
            

            

                
                                                // Rule at src/opts/algebraic.isle line 167.

            

        

            

                3449
            

            

                
            

            

                
                                                returns.push(v68);

            

        

            

                3450
            

            

                
            

            

                
                                            }

            

        

            

                3451
            

            

                
            

            

                
                                        }

            

        

            

                3452
            

            

                
            

            

                
                                        _ => {}

            

        

            

                3453
            

            

                
            

            

                
                                    }

            

        

            

                3454
            

            

                
            

            

                
                                }

            

        

            

                3455
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                3456
            

            

                
            

            

                
                                    opcode: ref v11,

            

        

            

                3457
            

            

                
            

            

                
                                    arg: v12,

            

        

            

                3458
            

            

                
            

            

                
                                } => {

            

        

            

                3459
            

            

                
            

            

                
                                    if let &Opcode::Bnot = v11 {

            

        

            

                3460
            

            

                
            

            

                
                                        if v2.0 == v8.0 {

            

        

            

                3461
            

            

                
            

            

                
                                            let v37 = C::subsume(ctx, v12);

            

        

            

                3462
            

            

                
            

            

                
                                            // Rule at src/opts/algebraic.isle line 163.

            

        

            

                3463
            

            

                
            

            

                
                                            returns.push(v37);

            

        

            

                3464
            

            

                
            

            

                
                                        }

            

        

            

                3465
            

            

                
            

            

                
                                    }

            

        

            

                3466
            

            

                
            

            

                
                                }

            

        

            

                3467
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                3468
            

            

                
            

            

                
                                    opcode: ref v313,

            

        

            

                3469
            

            

                
            

            

                
                                    imm: v314,

            

        

            

                3470
            

            

                
            

            

                
                                } => {

            

        

            

                3471
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v313 {

            

        

            

                3472
            

            

                
            

            

                
                                        let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                3473
            

            

                
            

            

                
                                        if let Some(v47) = v46 {

            

        

            

                3474
            

            

                
            

            

                
                                            if v8.0 == v47 {

            

        

            

                3475
            

            

                
            

            

                
                                                let v315 = C::u64_from_imm64(ctx, v314);

            

        

            

                3476
            

            

                
            

            

                
                                                let v316 = C::u64_not(ctx, v315);

            

        

            

                3477
            

            

                
            

            

                
                                                let v317 = C::imm64_masked(ctx, v47, v316);

            

        

            

                3478
            

            

                
            

            

                
                                                let v318 = constructor_iconst(ctx, v47, v317);

            

        

            

                3479
            

            

                
            

            

                
                                                let v319 = C::subsume(ctx, v318);

            

        

            

                3480
            

            

                
            

            

                
                                                // Rule at src/opts/cprop.isle line 53.

            

        

            

                3481
            

            

                
            

            

                
                                                returns.push(v319);

            

        

            

                3482
            

            

                
            

            

                
                                            }

            

        

            

                3483
            

            

                
            

            

                
                                        }

            

        

            

                3484
            

            

                
            

            

                
                                    }

            

        

            

                3485
            

            

                
            

            

                
                                }

            

        

            

                3486
            

            

                
            

            

                
                                _ => {}

            

        

            

                3487
            

            

                
            

            

                
                            }

            

        

            

                3488
            

            

                
            

            

                
                        }

            

        

            

                3489
            

            

                
            

            

                
                        let v138 = C::remat(ctx, arg0);

            

        

            

                3490
            

            

                
            

            

                
                        // Rule at src/opts/algebraic.isle line 316.

            

        

            

                3491
            

            

                
            

            

                
                        returns.push(v138);

            

        

            

                3492
            

            

                
            

            

                
                    }

            

        

            

                3493
            

            

                
            

            

                
                    &Opcode::Fneg => {

            

        

            

                3494
            

            

                
            

            

                
                        let v7 = C::inst_data_etor(ctx, v6);

            

        

            

                3495
            

            

                
            

            

                
                        let mut v7 = v7;

            

        

            

                3496
            

            

                
            

            

                
                        while let Some(v8) = v7.next(ctx) {

            

        

            

                3497
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                3498
            

            

                
            

            

                
                                opcode: ref v11,

            

        

            

                3499
            

            

                
            

            

                
                                arg: v12,

            

        

            

                3500
            

            

                
            

            

                
                            } = &v8.1

            

        

            

                3501
            

            

                
            

            

                
                            {

            

        

            

                3502
            

            

                
            

            

                
                                if let &Opcode::Fneg = v11 {

            

        

            

                3503
            

            

                
            

            

                
                                    if v2.0 == v8.0 {

            

        

            

                3504
            

            

                
            

            

                
                                        let v37 = C::subsume(ctx, v12);

            

        

            

                3505
            

            

                
            

            

                
                                        // Rule at src/opts/algebraic.isle line 401.

            

        

            

                3506
            

            

                
            

            

                
                                        returns.push(v37);

            

        

            

                3507
            

            

                
            

            

                
                                    }

            

        

            

                3508
            

            

                
            

            

                
                                }

            

        

            

                3509
            

            

                
            

            

                
                            }

            

        

            

                3510
            

            

                
            

            

                
                        }

            

        

            

                3511
            

            

                
            

            

                
                    }

            

        

            

                3512
            

            

                
            

            

                
                    &Opcode::Uextend => {

            

        

            

                3513
            

            

                
            

            

                
                        let v7 = C::inst_data_etor(ctx, v6);

            

        

            

                3514
            

            

                
            

            

                
                        let mut v7 = v7;

            

        

            

                3515
            

            

                
            

            

                
                        while let Some(v8) = v7.next(ctx) {

            

        

            

                3516
            

            

                
            

            

                
                            match &v8.1 {

            

        

            

                3517
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                3518
            

            

                
            

            

                
                                    opcode: ref v11,

            

        

            

                3519
            

            

                
            

            

                
                                    arg: v12,

            

        

            

                3520
            

            

                
            

            

                
                                } => {

            

        

            

                3521
            

            

                
            

            

                
                                    if let &Opcode::Uextend = v11 {

            

        

            

                3522
            

            

                
            

            

                
                                        let v13 = constructor_uextend(ctx, v2.0, v12);

            

        

            

                3523
            

            

                
            

            

                
                                        // Rule at src/opts/algebraic.isle line 10.

            

        

            

                3524
            

            

                
            

            

                
                                        returns.push(v13);

            

        

            

                3525
            

            

                
            

            

                
                                    }

            

        

            

                3526
            

            

                
            

            

                
                                }

            

        

            

                3527
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                3528
            

            

                
            

            

                
                                    opcode: ref v313,

            

        

            

                3529
            

            

                
            

            

                
                                    imm: v314,

            

        

            

                3530
            

            

                
            

            

                
                                } => {

            

        

            

                3531
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v313 {

            

        

            

                3532
            

            

                
            

            

                
                                        let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                3533
            

            

                
            

            

                
                                        if let Some(v47) = v46 {

            

        

            

                3534
            

            

                
            

            

                
                                            let v329 = C::u64_uextend_imm64(ctx, v8.0, v314);

            

        

            

                3535
            

            

                
            

            

                
                                            let v330 = C::imm64(ctx, v329);

            

        

            

                3536
            

            

                
            

            

                
                                            let v331 = constructor_iconst(ctx, v47, v330);

            

        

            

                3537
            

            

                
            

            

                
                                            let v332 = C::subsume(ctx, v331);

            

        

            

                3538
            

            

                
            

            

                
                                            // Rule at src/opts/cprop.isle line 73.

            

        

            

                3539
            

            

                
            

            

                
                                            returns.push(v332);

            

        

            

                3540
            

            

                
            

            

                
                                        }

            

        

            

                3541
            

            

                
            

            

                
                                    }

            

        

            

                3542
            

            

                
            

            

                
                                }

            

        

            

                3543
            

            

                
            

            

                
                                _ => {}

            

        

            

                3544
            

            

                
            

            

                
                            }

            

        

            

                3545
            

            

                
            

            

                
                        }

            

        

            

                3546
            

            

                
            

            

                
                    }

            

        

            

                3547
            

            

                
            

            

                
                    &Opcode::Sextend => {

            

        

            

                3548
            

            

                
            

            

                
                        let v7 = C::inst_data_etor(ctx, v6);

            

        

            

                3549
            

            

                
            

            

                
                        let mut v7 = v7;

            

        

            

                3550
            

            

                
            

            

                
                        while let Some(v8) = v7.next(ctx) {

            

        

            

                3551
            

            

                
            

            

                
                            match &v8.1 {

            

        

            

                3552
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                3553
            

            

                
            

            

                
                                    opcode: ref v11,

            

        

            

                3554
            

            

                
            

            

                
                                    arg: v12,

            

        

            

                3555
            

            

                
            

            

                
                                } => {

            

        

            

                3556
            

            

                
            

            

                
                                    if let &Opcode::Sextend = v11 {

            

        

            

                3557
            

            

                
            

            

                
                                        let v14 = constructor_sextend(ctx, v2.0, v12);

            

        

            

                3558
            

            

                
            

            

                
                                        // Rule at src/opts/algebraic.isle line 12.

            

        

            

                3559
            

            

                
            

            

                
                                        returns.push(v14);

            

        

            

                3560
            

            

                
            

            

                
                                    }

            

        

            

                3561
            

            

                
            

            

                
                                }

            

        

            

                3562
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                3563
            

            

                
            

            

                
                                    opcode: ref v313,

            

        

            

                3564
            

            

                
            

            

                
                                    imm: v314,

            

        

            

                3565
            

            

                
            

            

                
                                } => {

            

        

            

                3566
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v313 {

            

        

            

                3567
            

            

                
            

            

                
                                        let v46 = C::fits_in_64(ctx, v2.0);

            

        

            

                3568
            

            

                
            

            

                
                                        if let Some(v47) = v46 {

            

        

            

                3569
            

            

                
            

            

                
                                            let v333 = C::i64_sextend_imm64(ctx, v8.0, v314);

            

        

            

                3570
            

            

                
            

            

                
                                            let v334 = C::i64_as_u64(ctx, v333);

            

        

            

                3571
            

            

                
            

            

                
                                            let v335 = C::imm64_masked(ctx, v47, v334);

            

        

            

                3572
            

            

                
            

            

                
                                            let v336 = constructor_iconst(ctx, v47, v335);

            

        

            

                3573
            

            

                
            

            

                
                                            let v337 = C::subsume(ctx, v336);

            

        

            

                3574
            

            

                
            

            

                
                                            // Rule at src/opts/cprop.isle line 76.

            

        

            

                3575
            

            

                
            

            

                
                                            returns.push(v337);

            

        

            

                3576
            

            

                
            

            

                
                                        }

            

        

            

                3577
            

            

                
            

            

                
                                    }

            

        

            

                3578
            

            

                
            

            

                
                                }

            

        

            

                3579
            

            

                
            

            

                
                                _ => {}

            

        

            

                3580
            

            

                
            

            

                
                            }

            

        

            

                3581
            

            

                
            

            

                
                        }

            

        

            

                3582
            

            

                
            

            

                
                    }

            

        

            

                3583
            

            

                
            

            

                
                    _ => {}

            

        

            

                3584
            

            

                
            

            

                
                }

            

        

            

                3585
            

            

                
            

            

                
            }

            

        

            

                3586
            

            

                
            

            

                
            &InstructionData::UnaryIeee32 {

            

        

            

                3587
            

            

                
            

            

                
                opcode: ref v141,

            

        

            

                3588
            

            

                
            

            

                
                imm: v142,

            

        

            

                3589
            

            

                
            

            

                
            } => {

            

        

            

                3590
            

            

                
            

            

                
                if let &Opcode::F32const = v141 {

            

        

            

                3591
            

            

                
            

            

                
                    let v138 = C::remat(ctx, arg0);

            

        

            

                3592
            

            

                
            

            

                
                    // Rule at src/opts/algebraic.isle line 320.

            

        

            

                3593
            

            

                
            

            

                
                    returns.push(v138);

            

        

            

                3594
            

            

                
            

            

                
                }

            

        

            

                3595
            

            

                
            

            

                
            }

            

        

            

                3596
            

            

                
            

            

                
            &InstructionData::UnaryIeee64 {

            

        

            

                3597
            

            

                
            

            

                
                opcode: ref v143,

            

        

            

                3598
            

            

                
            

            

                
                imm: v144,

            

        

            

                3599
            

            

                
            

            

                
            } => {

            

        

            

                3600
            

            

                
            

            

                
                if let &Opcode::F64const = v143 {

            

        

            

                3601
            

            

                
            

            

                
                    let v138 = C::remat(ctx, arg0);

            

        

            

                3602
            

            

                
            

            

                
                    // Rule at src/opts/algebraic.isle line 322.

            

        

            

                3603
            

            

                
            

            

                
                    returns.push(v138);

            

        

            

                3604
            

            

                
            

            

                
                }

            

        

            

                3605
            

            

                
            

            

                
            }

            

        

            

                3606
            

            

                
            

            

                
            &InstructionData::UnaryImm {

            

        

            

                3607
            

            

                
            

            

                
                opcode: ref v139,

            

        

            

                3608
            

            

                
            

            

                
                imm: v140,

            

        

            

                3609
            

            

                
            

            

                
            } => {

            

        

            

                3610
            

            

                
            

            

                
                if let &Opcode::Iconst = v139 {

            

        

            

                3611
            

            

                
            

            

                
                    let v138 = C::remat(ctx, arg0);

            

        

            

                3612
            

            

                
            

            

                
                    // Rule at src/opts/algebraic.isle line 318.

            

        

            

                3613
            

            

                
            

            

                
                    returns.push(v138);

            

        

            

                3614
            

            

                
            

            

                
                }

            

        

            

                3615
            

            

                
            

            

                
            }

            

        

            

                3616
            

            

                
            

            

                
            _ => {}

            

        

            

                3617
            

            

                
            

            

                
        }

            

        

            

                3618
            

            

                
            

            

                
    }

            

        

            

                3619
            

            

                
            

            

                
    return ContextIterWrapper::from(returns.into_iter());

            

        

            

                3620
            

            

                
            

            

                
}

            

        

            

                3621
            

            

                
            

            

                

            

        

            

                3622
            

            

                
            

            

                
// Generated as internal constructor for term intcc_comparable.

            

        

            

                3623
            

            

                
            

            

                
pub fn constructor_intcc_comparable<C: Context>(

            

        

            

                3624
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                3625
            

            

                
            

            

                
    arg0: &IntCC,

            

        

            

                3626
            

            

                
            

            

                
    arg1: &IntCC,

            

        

            

                3627
            

            

                
            

            

                
) -> Option<bool> {

            

        

            

                3628
            

            

                
            

            

                
    let v2 = constructor_intcc_class(ctx, arg0);

            

        

            

                3629
            

            

                
            

            

                
    let v3 = constructor_intcc_class(ctx, arg1);

            

        

            

                3630
            

            

                
            

            

                
    let v4 = C::u64_and(ctx, v2, v3);

            

        

            

                3631
            

            

                
            

            

                
    let v5 = C::u64_is_zero(ctx, v4);

            

        

            

                3632
            

            

                
            

            

                
    if v5 == false {

            

        

            

                3633
            

            

                
            

            

                
        let v7 = C::u64_eq(ctx, 0x2, v4);

            

        

            

                3634
            

            

                
            

            

                
        // Rule at src/opts/icmp.isle line 137.

            

        

            

                3635
            

            

                
            

            

                
        return Some(v7);

            

        

            

                3636
            

            

                
            

            

                
    }

            

        

            

                3637
            

            

                
            

            

                
    None

            

        

            

                3638
            

            

                
            

            

                
}

            

        

            

                3639
            

            

                
            

            

                

            

        

            

                3640
            

            

                
            

            

                
// Generated as internal constructor for term decompose_intcc.

            

        

            

                3641
            

            

                
            

            

                
pub fn constructor_decompose_intcc<C: Context>(ctx: &mut C, arg0: &IntCC) -> u64 {

            

        

            

                3642
            

            

                
            

            

                
    match arg0 {

            

        

            

                3643
            

            

                
            

            

                
        &IntCC::Equal => {

            

        

            

                3644
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 142.

            

        

            

                3645
            

            

                
            

            

                
            return 0x1;

            

        

            

                3646
            

            

                
            

            

                
        }

            

        

            

                3647
            

            

                
            

            

                
        &IntCC::NotEqual => {

            

        

            

                3648
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 151.

            

        

            

                3649
            

            

                
            

            

                
            return 0x6;

            

        

            

                3650
            

            

                
            

            

                
        }

            

        

            

                3651
            

            

                
            

            

                
        &IntCC::SignedGreaterThan => {

            

        

            

                3652
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 148.

            

        

            

                3653
            

            

                
            

            

                
            return 0x4;

            

        

            

                3654
            

            

                
            

            

                
        }

            

        

            

                3655
            

            

                
            

            

                
        &IntCC::SignedGreaterThanOrEqual => {

            

        

            

                3656
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 150.

            

        

            

                3657
            

            

                
            

            

                
            return 0x5;

            

        

            

                3658
            

            

                
            

            

                
        }

            

        

            

                3659
            

            

                
            

            

                
        &IntCC::SignedLessThan => {

            

        

            

                3660
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 144.

            

        

            

                3661
            

            

                
            

            

                
            return 0x2;

            

        

            

                3662
            

            

                
            

            

                
        }

            

        

            

                3663
            

            

                
            

            

                
        &IntCC::SignedLessThanOrEqual => {

            

        

            

                3664
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 146.

            

        

            

                3665
            

            

                
            

            

                
            return 0x3;

            

        

            

                3666
            

            

                
            

            

                
        }

            

        

            

                3667
            

            

                
            

            

                
        &IntCC::UnsignedGreaterThan => {

            

        

            

                3668
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 147.

            

        

            

                3669
            

            

                
            

            

                
            return 0x4;

            

        

            

                3670
            

            

                
            

            

                
        }

            

        

            

                3671
            

            

                
            

            

                
        &IntCC::UnsignedGreaterThanOrEqual => {

            

        

            

                3672
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 149.

            

        

            

                3673
            

            

                
            

            

                
            return 0x5;

            

        

            

                3674
            

            

                
            

            

                
        }

            

        

            

                3675
            

            

                
            

            

                
        &IntCC::UnsignedLessThan => {

            

        

            

                3676
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 143.

            

        

            

                3677
            

            

                
            

            

                
            return 0x2;

            

        

            

                3678
            

            

                
            

            

                
        }

            

        

            

                3679
            

            

                
            

            

                
        &IntCC::UnsignedLessThanOrEqual => {

            

        

            

                3680
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 145.

            

        

            

                3681
            

            

                
            

            

                
            return 0x3;

            

        

            

                3682
            

            

                
            

            

                
        }

            

        

            

                3683
            

            

                
            

            

                
        _ => {}

            

        

            

                3684
            

            

                
            

            

                
    }

            

        

            

                3685
            

            

                
            

            

                
    unreachable!(

            

        

            

                3686
            

            

                
            

            

                
        "no rule matched for term {} at {}; should it be partial?",

            

        

            

                3687
            

            

                
            

            

                
        "decompose_intcc", "src/opts/icmp.isle line 141"

            

        

            

                3688
            

            

                
            

            

                
    )

            

        

            

                3689
            

            

                
            

            

                
}

            

        

            

                3690
            

            

                
            

            

                

            

        

            

                3691
            

            

                
            

            

                
// Generated as internal constructor for term compose_icmp.

            

        

            

                3692
            

            

                
            

            

                
pub fn constructor_compose_icmp<C: Context>(

            

        

            

                3693
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                3694
            

            

                
            

            

                
    arg0: Type,

            

        

            

                3695
            

            

                
            

            

                
    arg1: u64,

            

        

            

                3696
            

            

                
            

            

                
    arg2: bool,

            

        

            

                3697
            

            

                
            

            

                
    arg3: Value,

            

        

            

                3698
            

            

                
            

            

                
    arg4: Value,

            

        

            

                3699
            

            

                
            

            

                
) -> Value {

            

        

            

                3700
            

            

                
            

            

                
    match arg1 {

            

        

            

                3701
            

            

                
            

            

                
        0x0 => {

            

        

            

                3702
            

            

                
            

            

                
            let v6 = C::imm64(ctx, 0x0);

            

        

            

                3703
            

            

                
            

            

                
            let v7 = constructor_iconst(ctx, arg0, v6);

            

        

            

                3704
            

            

                
            

            

                
            let v8 = C::subsume(ctx, v7);

            

        

            

                3705
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 154.

            

        

            

                3706
            

            

                
            

            

                
            return v8;

            

        

            

                3707
            

            

                
            

            

                
        }

            

        

            

                3708
            

            

                
            

            

                
        0x1 => {

            

        

            

                3709
            

            

                
            

            

                
            let v10 = constructor_icmp(ctx, arg0, &IntCC::Equal, arg3, arg4);

            

        

            

                3710
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 155.

            

        

            

                3711
            

            

                
            

            

                
            return v10;

            

        

            

                3712
            

            

                
            

            

                
        }

            

        

            

                3713
            

            

                
            

            

                
        0x2 => {

            

        

            

                3714
            

            

                
            

            

                
            match arg2 {

            

        

            

                3715
            

            

                
            

            

                
                true => {

            

        

            

                3716
            

            

                
            

            

                
                    let v14 = constructor_icmp(ctx, arg0, &IntCC::SignedLessThan, arg3, arg4);

            

        

            

                3717
            

            

                
            

            

                
                    // Rule at src/opts/icmp.isle line 157.

            

        

            

                3718
            

            

                
            

            

                
                    return v14;

            

        

            

                3719
            

            

                
            

            

                
                }

            

        

            

                3720
            

            

                
            

            

                
                false => {

            

        

            

                3721
            

            

                
            

            

                
                    let v12 = constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThan, arg3, arg4);

            

        

            

                3722
            

            

                
            

            

                
                    // Rule at src/opts/icmp.isle line 156.

            

        

            

                3723
            

            

                
            

            

                
                    return v12;

            

        

            

                3724
            

            

                
            

            

                
                }

            

        

            

                3725
            

            

                
            

            

                
                _ => {}

            

        

            

                3726
            

            

                
            

            

                
            }

            

        

            

                3727
            

            

                
            

            

                
        }

            

        

            

                3728
            

            

                
            

            

                
        0x3 => {

            

        

            

                3729
            

            

                
            

            

                
            match arg2 {

            

        

            

                3730
            

            

                
            

            

                
                true => {

            

        

            

                3731
            

            

                
            

            

                
                    let v18 =

            

        

            

                3732
            

            

                
            

            

                
                        constructor_icmp(ctx, arg0, &IntCC::SignedLessThanOrEqual, arg3, arg4);

            

        

            

                3733
            

            

                
            

            

                
                    // Rule at src/opts/icmp.isle line 159.

            

        

            

                3734
            

            

                
            

            

                
                    return v18;

            

        

            

                3735
            

            

                
            

            

                
                }

            

        

            

                3736
            

            

                
            

            

                
                false => {

            

        

            

                3737
            

            

                
            

            

                
                    let v16 =

            

        

            

                3738
            

            

                
            

            

                
                        constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThanOrEqual, arg3, arg4);

            

        

            

                3739
            

            

                
            

            

                
                    // Rule at src/opts/icmp.isle line 158.

            

        

            

                3740
            

            

                
            

            

                
                    return v16;

            

        

            

                3741
            

            

                
            

            

                
                }

            

        

            

                3742
            

            

                
            

            

                
                _ => {}

            

        

            

                3743
            

            

                
            

            

                
            }

            

        

            

                3744
            

            

                
            

            

                
        }

            

        

            

                3745
            

            

                
            

            

                
        0x4 => {

            

        

            

                3746
            

            

                
            

            

                
            match arg2 {

            

        

            

                3747
            

            

                
            

            

                
                true => {

            

        

            

                3748
            

            

                
            

            

                
                    let v22 = constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThan, arg3, arg4);

            

        

            

                3749
            

            

                
            

            

                
                    // Rule at src/opts/icmp.isle line 161.

            

        

            

                3750
            

            

                
            

            

                
                    return v22;

            

        

            

                3751
            

            

                
            

            

                
                }

            

        

            

                3752
            

            

                
            

            

                
                false => {

            

        

            

                3753
            

            

                
            

            

                
                    let v20 = constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThan, arg3, arg4);

            

        

            

                3754
            

            

                
            

            

                
                    // Rule at src/opts/icmp.isle line 160.

            

        

            

                3755
            

            

                
            

            

                
                    return v20;

            

        

            

                3756
            

            

                
            

            

                
                }

            

        

            

                3757
            

            

                
            

            

                
                _ => {}

            

        

            

                3758
            

            

                
            

            

                
            }

            

        

            

                3759
            

            

                
            

            

                
        }

            

        

            

                3760
            

            

                
            

            

                
        0x5 => {

            

        

            

                3761
            

            

                
            

            

                
            match arg2 {

            

        

            

                3762
            

            

                
            

            

                
                true => {

            

        

            

                3763
            

            

                
            

            

                
                    let v26 =

            

        

            

                3764
            

            

                
            

            

                
                        constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThanOrEqual, arg3, arg4);

            

        

            

                3765
            

            

                
            

            

                
                    // Rule at src/opts/icmp.isle line 163.

            

        

            

                3766
            

            

                
            

            

                
                    return v26;

            

        

            

                3767
            

            

                
            

            

                
                }

            

        

            

                3768
            

            

                
            

            

                
                false => {

            

        

            

                3769
            

            

                
            

            

                
                    let v24 =

            

        

            

                3770
            

            

                
            

            

                
                        constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThanOrEqual, arg3, arg4);

            

        

            

                3771
            

            

                
            

            

                
                    // Rule at src/opts/icmp.isle line 162.

            

        

            

                3772
            

            

                
            

            

                
                    return v24;

            

        

            

                3773
            

            

                
            

            

                
                }

            

        

            

                3774
            

            

                
            

            

                
                _ => {}

            

        

            

                3775
            

            

                
            

            

                
            }

            

        

            

                3776
            

            

                
            

            

                
        }

            

        

            

                3777
            

            

                
            

            

                
        0x6 => {

            

        

            

                3778
            

            

                
            

            

                
            let v28 = constructor_icmp(ctx, arg0, &IntCC::NotEqual, arg3, arg4);

            

        

            

                3779
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 164.

            

        

            

                3780
            

            

                
            

            

                
            return v28;

            

        

            

                3781
            

            

                
            

            

                
        }

            

        

            

                3782
            

            

                
            

            

                
        0x7 => {

            

        

            

                3783
            

            

                
            

            

                
            let v30 = C::imm64(ctx, 0x1);

            

        

            

                3784
            

            

                
            

            

                
            let v31 = constructor_iconst(ctx, arg0, v30);

            

        

            

                3785
            

            

                
            

            

                
            let v32 = C::subsume(ctx, v31);

            

        

            

                3786
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 165.

            

        

            

                3787
            

            

                
            

            

                
            return v32;

            

        

            

                3788
            

            

                
            

            

                
        }

            

        

            

                3789
            

            

                
            

            

                
        _ => {}

            

        

            

                3790
            

            

                
            

            

                
    }

            

        

            

                3791
            

            

                
            

            

                
    unreachable!(

            

        

            

                3792
            

            

                
            

            

                
        "no rule matched for term {} at {}; should it be partial?",

            

        

            

                3793
            

            

                
            

            

                
        "compose_icmp", "src/opts/icmp.isle line 153"

            

        

            

                3794
            

            

                
            

            

                
    )

            

        

            

                3795
            

            

                
            

            

                
}

            

        

            

                3796
            

            

                
            

            

                

            

        

            

                3797
            

            

                
            

            

                
// Generated as internal constructor for term intcc_class.

            

        

            

                3798
            

            

                
            

            

                
pub fn constructor_intcc_class<C: Context>(ctx: &mut C, arg0: &IntCC) -> u64 {

            

        

            

                3799
            

            

                
            

            

                
    match arg0 {

            

        

            

                3800
            

            

                
            

            

                
        &IntCC::Equal => {

            

        

            

                3801
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 176.

            

        

            

                3802
            

            

                
            

            

                
            return 0x3;

            

        

            

                3803
            

            

                
            

            

                
        }

            

        

            

                3804
            

            

                
            

            

                
        &IntCC::NotEqual => {

            

        

            

                3805
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 177.

            

        

            

                3806
            

            

                
            

            

                
            return 0x3;

            

        

            

                3807
            

            

                
            

            

                
        }

            

        

            

                3808
            

            

                
            

            

                
        &IntCC::SignedGreaterThan => {

            

        

            

                3809
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 174.

            

        

            

                3810
            

            

                
            

            

                
            return 0x2;

            

        

            

                3811
            

            

                
            

            

                
        }

            

        

            

                3812
            

            

                
            

            

                
        &IntCC::SignedGreaterThanOrEqual => {

            

        

            

                3813
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 175.

            

        

            

                3814
            

            

                
            

            

                
            return 0x2;

            

        

            

                3815
            

            

                
            

            

                
        }

            

        

            

                3816
            

            

                
            

            

                
        &IntCC::SignedLessThan => {

            

        

            

                3817
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 172.

            

        

            

                3818
            

            

                
            

            

                
            return 0x2;

            

        

            

                3819
            

            

                
            

            

                
        }

            

        

            

                3820
            

            

                
            

            

                
        &IntCC::SignedLessThanOrEqual => {

            

        

            

                3821
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 173.

            

        

            

                3822
            

            

                
            

            

                
            return 0x2;

            

        

            

                3823
            

            

                
            

            

                
        }

            

        

            

                3824
            

            

                
            

            

                
        &IntCC::UnsignedGreaterThan => {

            

        

            

                3825
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 170.

            

        

            

                3826
            

            

                
            

            

                
            return 0x1;

            

        

            

                3827
            

            

                
            

            

                
        }

            

        

            

                3828
            

            

                
            

            

                
        &IntCC::UnsignedGreaterThanOrEqual => {

            

        

            

                3829
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 171.

            

        

            

                3830
            

            

                
            

            

                
            return 0x1;

            

        

            

                3831
            

            

                
            

            

                
        }

            

        

            

                3832
            

            

                
            

            

                
        &IntCC::UnsignedLessThan => {

            

        

            

                3833
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 168.

            

        

            

                3834
            

            

                
            

            

                
            return 0x1;

            

        

            

                3835
            

            

                
            

            

                
        }

            

        

            

                3836
            

            

                
            

            

                
        &IntCC::UnsignedLessThanOrEqual => {

            

        

            

                3837
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 169.

            

        

            

                3838
            

            

                
            

            

                
            return 0x1;

            

        

            

                3839
            

            

                
            

            

                
        }

            

        

            

                3840
            

            

                
            

            

                
        _ => {}

            

        

            

                3841
            

            

                
            

            

                
    }

            

        

            

                3842
            

            

                
            

            

                
    unreachable!(

            

        

            

                3843
            

            

                
            

            

                
        "no rule matched for term {} at {}; should it be partial?",

            

        

            

                3844
            

            

                
            

            

                
        "intcc_class", "src/opts/icmp.isle line 167"

            

        

            

                3845
            

            

                
            

            

                
    )

            

        

            

                3846
            

            

                
            

            

                
}

            

        

            

                3847
            

            

                
            

            

                

            

        

            

                3848
            

            

                
            

            

                
// Generated as internal constructor for term func_addr.

            

        

            

                3849
            

            

                
            

            

                
pub fn constructor_func_addr<C: Context>(ctx: &mut C, arg0: Type, arg1: FuncRef) -> Value {

            

        

            

                3850
            

            

                
            

            

                
    let v3 = InstructionData::FuncAddr {

            

        

            

                3851
            

            

                
            

            

                
        opcode: Opcode::FuncAddr,

            

        

            

                3852
            

            

                
            

            

                
        func_ref: arg1,

            

        

            

                3853
            

            

                
            

            

                
    };

            

        

            

                3854
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                3855
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 360.

            

        

            

                3856
            

            

                
            

            

                
    return v4;

            

        

            

                3857
            

            

                
            

            

                
}

            

        

            

                3858
            

            

                
            

            

                

            

        

            

                3859
            

            

                
            

            

                
// Generated as internal constructor for term splat.

            

        

            

                3860
            

            

                
            

            

                
pub fn constructor_splat<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                3861
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                3862
            

            

                
            

            

                
        opcode: Opcode::Splat,

            

        

            

                3863
            

            

                
            

            

                
        arg: arg1,

            

        

            

                3864
            

            

                
            

            

                
    };

            

        

            

                3865
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                3866
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 369.

            

        

            

                3867
            

            

                
            

            

                
    return v4;

            

        

            

                3868
            

            

                
            

            

                
}

            

        

            

                3869
            

            

                
            

            

                

            

        

            

                3870
            

            

                
            

            

                
// Generated as internal constructor for term swizzle.

            

        

            

                3871
            

            

                
            

            

                
pub fn constructor_swizzle<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                3872
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                3873
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                3874
            

            

                
            

            

                
        opcode: Opcode::Swizzle,

            

        

            

                3875
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                3876
            

            

                
            

            

                
    };

            

        

            

                3877
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                3878
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 378.

            

        

            

                3879
            

            

                
            

            

                
    return v6;

            

        

            

                3880
            

            

                
            

            

                
}

            

        

            

                3881
            

            

                
            

            

                

            

        

            

                3882
            

            

                
            

            

                
// Generated as internal constructor for term x86_pshufb.

            

        

            

                3883
            

            

                
            

            

                
pub fn constructor_x86_pshufb<C: Context>(

            

        

            

                3884
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                3885
            

            

                
            

            

                
    arg0: Type,

            

        

            

                3886
            

            

                
            

            

                
    arg1: Value,

            

        

            

                3887
            

            

                
            

            

                
    arg2: Value,

            

        

            

                3888
            

            

                
            

            

                
) -> Value {

            

        

            

                3889
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                3890
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                3891
            

            

                
            

            

                
        opcode: Opcode::X86Pshufb,

            

        

            

                3892
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                3893
            

            

                
            

            

                
    };

            

        

            

                3894
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                3895
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 387.

            

        

            

                3896
            

            

                
            

            

                
    return v6;

            

        

            

                3897
            

            

                
            

            

                
}

            

        

            

                3898
            

            

                
            

            

                

            

        

            

                3899
            

            

                
            

            

                
// Generated as internal constructor for term insertlane.

            

        

            

                3900
            

            

                
            

            

                
pub fn constructor_insertlane<C: Context>(

            

        

            

                3901
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                3902
            

            

                
            

            

                
    arg0: Type,

            

        

            

                3903
            

            

                
            

            

                
    arg1: Value,

            

        

            

                3904
            

            

                
            

            

                
    arg2: Value,

            

        

            

                3905
            

            

                
            

            

                
    arg3: Uimm8,

            

        

            

                3906
            

            

                
            

            

                
) -> Value {

            

        

            

                3907
            

            

                
            

            

                
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                3908
            

            

                
            

            

                
    let v6 = InstructionData::TernaryImm8 {

            

        

            

                3909
            

            

                
            

            

                
        opcode: Opcode::Insertlane,

            

        

            

                3910
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                3911
            

            

                
            

            

                
        imm: arg3,

            

        

            

                3912
            

            

                
            

            

                
    };

            

        

            

                3913
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                3914
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 396.

            

        

            

                3915
            

            

                
            

            

                
    return v7;

            

        

            

                3916
            

            

                
            

            

                
}

            

        

            

                3917
            

            

                
            

            

                

            

        

            

                3918
            

            

                
            

            

                
// Generated as internal constructor for term extractlane.

            

        

            

                3919
            

            

                
            

            

                
pub fn constructor_extractlane<C: Context>(

            

        

            

                3920
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                3921
            

            

                
            

            

                
    arg0: Type,

            

        

            

                3922
            

            

                
            

            

                
    arg1: Value,

            

        

            

                3923
            

            

                
            

            

                
    arg2: Uimm8,

            

        

            

                3924
            

            

                
            

            

                
) -> Value {

            

        

            

                3925
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm8 {

            

        

            

                3926
            

            

                
            

            

                
        opcode: Opcode::Extractlane,

            

        

            

                3927
            

            

                
            

            

                
        arg: arg1,

            

        

            

                3928
            

            

                
            

            

                
        imm: arg2,

            

        

            

                3929
            

            

                
            

            

                
    };

            

        

            

                3930
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                3931
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 405.

            

        

            

                3932
            

            

                
            

            

                
    return v5;

            

        

            

                3933
            

            

                
            

            

                
}

            

        

            

                3934
            

            

                
            

            

                

            

        

            

                3935
            

            

                
            

            

                
// Generated as internal constructor for term smin.

            

        

            

                3936
            

            

                
            

            

                
pub fn constructor_smin<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                3937
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                3938
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                3939
            

            

                
            

            

                
        opcode: Opcode::Smin,

            

        

            

                3940
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                3941
            

            

                
            

            

                
    };

            

        

            

                3942
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                3943
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 414.

            

        

            

                3944
            

            

                
            

            

                
    return v6;

            

        

            

                3945
            

            

                
            

            

                
}

            

        

            

                3946
            

            

                
            

            

                

            

        

            

                3947
            

            

                
            

            

                
// Generated as internal constructor for term umin.

            

        

            

                3948
            

            

                
            

            

                
pub fn constructor_umin<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                3949
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                3950
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                3951
            

            

                
            

            

                
        opcode: Opcode::Umin,

            

        

            

                3952
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                3953
            

            

                
            

            

                
    };

            

        

            

                3954
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                3955
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 423.

            

        

            

                3956
            

            

                
            

            

                
    return v6;

            

        

            

                3957
            

            

                
            

            

                
}

            

        

            

                3958
            

            

                
            

            

                

            

        

            

                3959
            

            

                
            

            

                
// Generated as internal constructor for term smax.

            

        

            

                3960
            

            

                
            

            

                
pub fn constructor_smax<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                3961
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                3962
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                3963
            

            

                
            

            

                
        opcode: Opcode::Smax,

            

        

            

                3964
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                3965
            

            

                
            

            

                
    };

            

        

            

                3966
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                3967
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 432.

            

        

            

                3968
            

            

                
            

            

                
    return v6;

            

        

            

                3969
            

            

                
            

            

                
}

            

        

            

                3970
            

            

                
            

            

                

            

        

            

                3971
            

            

                
            

            

                
// Generated as internal constructor for term umax.

            

        

            

                3972
            

            

                
            

            

                
pub fn constructor_umax<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                3973
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                3974
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                3975
            

            

                
            

            

                
        opcode: Opcode::Umax,

            

        

            

                3976
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                3977
            

            

                
            

            

                
    };

            

        

            

                3978
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                3979
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 441.

            

        

            

                3980
            

            

                
            

            

                
    return v6;

            

        

            

                3981
            

            

                
            

            

                
}

            

        

            

                3982
            

            

                
            

            

                

            

        

            

                3983
            

            

                
            

            

                
// Generated as internal constructor for term avg_round.

            

        

            

                3984
            

            

                
            

            

                
pub fn constructor_avg_round<C: Context>(

            

        

            

                3985
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                3986
            

            

                
            

            

                
    arg0: Type,

            

        

            

                3987
            

            

                
            

            

                
    arg1: Value,

            

        

            

                3988
            

            

                
            

            

                
    arg2: Value,

            

        

            

                3989
            

            

                
            

            

                
) -> Value {

            

        

            

                3990
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                3991
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                3992
            

            

                
            

            

                
        opcode: Opcode::AvgRound,

            

        

            

                3993
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                3994
            

            

                
            

            

                
    };

            

        

            

                3995
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                3996
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 450.

            

        

            

                3997
            

            

                
            

            

                
    return v6;

            

        

            

                3998
            

            

                
            

            

                
}

            

        

            

                3999
            

            

                
            

            

                

            

        

            

                4000
            

            

                
            

            

                
// Generated as internal constructor for term uadd_sat.

            

        

            

                4001
            

            

                
            

            

                
pub fn constructor_uadd_sat<C: Context>(

            

        

            

                4002
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4003
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4004
            

            

                
            

            

                
    arg1: Value,

            

        

            

                4005
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4006
            

            

                
            

            

                
) -> Value {

            

        

            

                4007
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                4008
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                4009
            

            

                
            

            

                
        opcode: Opcode::UaddSat,

            

        

            

                4010
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                4011
            

            

                
            

            

                
    };

            

        

            

                4012
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4013
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 459.

            

        

            

                4014
            

            

                
            

            

                
    return v6;

            

        

            

                4015
            

            

                
            

            

                
}

            

        

            

                4016
            

            

                
            

            

                

            

        

            

                4017
            

            

                
            

            

                
// Generated as internal constructor for term sadd_sat.

            

        

            

                4018
            

            

                
            

            

                
pub fn constructor_sadd_sat<C: Context>(

            

        

            

                4019
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4020
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4021
            

            

                
            

            

                
    arg1: Value,

            

        

            

                4022
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4023
            

            

                
            

            

                
) -> Value {

            

        

            

                4024
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                4025
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                4026
            

            

                
            

            

                
        opcode: Opcode::SaddSat,

            

        

            

                4027
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                4028
            

            

                
            

            

                
    };

            

        

            

                4029
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4030
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 468.

            

        

            

                4031
            

            

                
            

            

                
    return v6;

            

        

            

                4032
            

            

                
            

            

                
}

            

        

            

                4033
            

            

                
            

            

                

            

        

            

                4034
            

            

                
            

            

                
// Generated as internal constructor for term usub_sat.

            

        

            

                4035
            

            

                
            

            

                
pub fn constructor_usub_sat<C: Context>(

            

        

            

                4036
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4037
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4038
            

            

                
            

            

                
    arg1: Value,

            

        

            

                4039
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4040
            

            

                
            

            

                
) -> Value {

            

        

            

                4041
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                4042
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                4043
            

            

                
            

            

                
        opcode: Opcode::UsubSat,

            

        

            

                4044
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                4045
            

            

                
            

            

                
    };

            

        

            

                4046
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4047
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 477.

            

        

            

                4048
            

            

                
            

            

                
    return v6;

            

        

            

                4049
            

            

                
            

            

                
}

            

        

            

                4050
            

            

                
            

            

                

            

        

            

                4051
            

            

                
            

            

                
// Generated as internal constructor for term ssub_sat.

            

        

            

                4052
            

            

                
            

            

                
pub fn constructor_ssub_sat<C: Context>(

            

        

            

                4053
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4054
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4055
            

            

                
            

            

                
    arg1: Value,

            

        

            

                4056
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4057
            

            

                
            

            

                
) -> Value {

            

        

            

                4058
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                4059
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                4060
            

            

                
            

            

                
        opcode: Opcode::SsubSat,

            

        

            

                4061
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                4062
            

            

                
            

            

                
    };

            

        

            

                4063
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4064
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 486.

            

        

            

                4065
            

            

                
            

            

                
    return v6;

            

        

            

                4066
            

            

                
            

            

                
}

            

        

            

                4067
            

            

                
            

            

                

            

        

            

                4068
            

            

                
            

            

                
// Generated as internal constructor for term load.

            

        

            

                4069
            

            

                
            

            

                
pub fn constructor_load<C: Context>(

            

        

            

                4070
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4071
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4072
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                4073
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4074
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                4075
            

            

                
            

            

                
) -> Value {

            

        

            

                4076
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                4077
            

            

                
            

            

                
        opcode: Opcode::Load,

            

        

            

                4078
            

            

                
            

            

                
        arg: arg2,

            

        

            

                4079
            

            

                
            

            

                
        flags: arg1,

            

        

            

                4080
            

            

                
            

            

                
        offset: arg3,

            

        

            

                4081
            

            

                
            

            

                
    };

            

        

            

                4082
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4083
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 495.

            

        

            

                4084
            

            

                
            

            

                
    return v6;

            

        

            

                4085
            

            

                
            

            

                
}

            

        

            

                4086
            

            

                
            

            

                

            

        

            

                4087
            

            

                
            

            

                
// Generated as internal constructor for term uload8.

            

        

            

                4088
            

            

                
            

            

                
pub fn constructor_uload8<C: Context>(

            

        

            

                4089
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4090
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4091
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                4092
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4093
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                4094
            

            

                
            

            

                
) -> Value {

            

        

            

                4095
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                4096
            

            

                
            

            

                
        opcode: Opcode::Uload8,

            

        

            

                4097
            

            

                
            

            

                
        arg: arg2,

            

        

            

                4098
            

            

                
            

            

                
        flags: arg1,

            

        

            

                4099
            

            

                
            

            

                
        offset: arg3,

            

        

            

                4100
            

            

                
            

            

                
    };

            

        

            

                4101
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4102
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 504.

            

        

            

                4103
            

            

                
            

            

                
    return v6;

            

        

            

                4104
            

            

                
            

            

                
}

            

        

            

                4105
            

            

                
            

            

                

            

        

            

                4106
            

            

                
            

            

                
// Generated as internal constructor for term sload8.

            

        

            

                4107
            

            

                
            

            

                
pub fn constructor_sload8<C: Context>(

            

        

            

                4108
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4109
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4110
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                4111
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4112
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                4113
            

            

                
            

            

                
) -> Value {

            

        

            

                4114
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                4115
            

            

                
            

            

                
        opcode: Opcode::Sload8,

            

        

            

                4116
            

            

                
            

            

                
        arg: arg2,

            

        

            

                4117
            

            

                
            

            

                
        flags: arg1,

            

        

            

                4118
            

            

                
            

            

                
        offset: arg3,

            

        

            

                4119
            

            

                
            

            

                
    };

            

        

            

                4120
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4121
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 513.

            

        

            

                4122
            

            

                
            

            

                
    return v6;

            

        

            

                4123
            

            

                
            

            

                
}

            

        

            

                4124
            

            

                
            

            

                

            

        

            

                4125
            

            

                
            

            

                
// Generated as internal constructor for term uload16.

            

        

            

                4126
            

            

                
            

            

                
pub fn constructor_uload16<C: Context>(

            

        

            

                4127
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4128
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4129
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                4130
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4131
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                4132
            

            

                
            

            

                
) -> Value {

            

        

            

                4133
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                4134
            

            

                
            

            

                
        opcode: Opcode::Uload16,

            

        

            

                4135
            

            

                
            

            

                
        arg: arg2,

            

        

            

                4136
            

            

                
            

            

                
        flags: arg1,

            

        

            

                4137
            

            

                
            

            

                
        offset: arg3,

            

        

            

                4138
            

            

                
            

            

                
    };

            

        

            

                4139
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4140
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 522.

            

        

            

                4141
            

            

                
            

            

                
    return v6;

            

        

            

                4142
            

            

                
            

            

                
}

            

        

            

                4143
            

            

                
            

            

                

            

        

            

                4144
            

            

                
            

            

                
// Generated as internal constructor for term sload16.

            

        

            

                4145
            

            

                
            

            

                
pub fn constructor_sload16<C: Context>(

            

        

            

                4146
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4147
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4148
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                4149
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4150
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                4151
            

            

                
            

            

                
) -> Value {

            

        

            

                4152
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                4153
            

            

                
            

            

                
        opcode: Opcode::Sload16,

            

        

            

                4154
            

            

                
            

            

                
        arg: arg2,

            

        

            

                4155
            

            

                
            

            

                
        flags: arg1,

            

        

            

                4156
            

            

                
            

            

                
        offset: arg3,

            

        

            

                4157
            

            

                
            

            

                
    };

            

        

            

                4158
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4159
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 531.

            

        

            

                4160
            

            

                
            

            

                
    return v6;

            

        

            

                4161
            

            

                
            

            

                
}

            

        

            

                4162
            

            

                
            

            

                

            

        

            

                4163
            

            

                
            

            

                
// Generated as internal constructor for term uload32.

            

        

            

                4164
            

            

                
            

            

                
pub fn constructor_uload32<C: Context>(

            

        

            

                4165
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4166
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4167
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                4168
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4169
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                4170
            

            

                
            

            

                
) -> Value {

            

        

            

                4171
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                4172
            

            

                
            

            

                
        opcode: Opcode::Uload32,

            

        

            

                4173
            

            

                
            

            

                
        arg: arg2,

            

        

            

                4174
            

            

                
            

            

                
        flags: arg1,

            

        

            

                4175
            

            

                
            

            

                
        offset: arg3,

            

        

            

                4176
            

            

                
            

            

                
    };

            

        

            

                4177
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4178
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 540.

            

        

            

                4179
            

            

                
            

            

                
    return v6;

            

        

            

                4180
            

            

                
            

            

                
}

            

        

            

                4181
            

            

                
            

            

                

            

        

            

                4182
            

            

                
            

            

                
// Generated as internal constructor for term sload32.

            

        

            

                4183
            

            

                
            

            

                
pub fn constructor_sload32<C: Context>(

            

        

            

                4184
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4185
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4186
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                4187
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4188
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                4189
            

            

                
            

            

                
) -> Value {

            

        

            

                4190
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                4191
            

            

                
            

            

                
        opcode: Opcode::Sload32,

            

        

            

                4192
            

            

                
            

            

                
        arg: arg2,

            

        

            

                4193
            

            

                
            

            

                
        flags: arg1,

            

        

            

                4194
            

            

                
            

            

                
        offset: arg3,

            

        

            

                4195
            

            

                
            

            

                
    };

            

        

            

                4196
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4197
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 549.

            

        

            

                4198
            

            

                
            

            

                
    return v6;

            

        

            

                4199
            

            

                
            

            

                
}

            

        

            

                4200
            

            

                
            

            

                

            

        

            

                4201
            

            

                
            

            

                
// Generated as internal constructor for term uload8x8.

            

        

            

                4202
            

            

                
            

            

                
pub fn constructor_uload8x8<C: Context>(

            

        

            

                4203
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4204
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4205
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                4206
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4207
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                4208
            

            

                
            

            

                
) -> Value {

            

        

            

                4209
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                4210
            

            

                
            

            

                
        opcode: Opcode::Uload8x8,

            

        

            

                4211
            

            

                
            

            

                
        arg: arg2,

            

        

            

                4212
            

            

                
            

            

                
        flags: arg1,

            

        

            

                4213
            

            

                
            

            

                
        offset: arg3,

            

        

            

                4214
            

            

                
            

            

                
    };

            

        

            

                4215
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4216
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 558.

            

        

            

                4217
            

            

                
            

            

                
    return v6;

            

        

            

                4218
            

            

                
            

            

                
}

            

        

            

                4219
            

            

                
            

            

                

            

        

            

                4220
            

            

                
            

            

                
// Generated as internal constructor for term sload8x8.

            

        

            

                4221
            

            

                
            

            

                
pub fn constructor_sload8x8<C: Context>(

            

        

            

                4222
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4223
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4224
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                4225
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4226
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                4227
            

            

                
            

            

                
) -> Value {

            

        

            

                4228
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                4229
            

            

                
            

            

                
        opcode: Opcode::Sload8x8,

            

        

            

                4230
            

            

                
            

            

                
        arg: arg2,

            

        

            

                4231
            

            

                
            

            

                
        flags: arg1,

            

        

            

                4232
            

            

                
            

            

                
        offset: arg3,

            

        

            

                4233
            

            

                
            

            

                
    };

            

        

            

                4234
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4235
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 567.

            

        

            

                4236
            

            

                
            

            

                
    return v6;

            

        

            

                4237
            

            

                
            

            

                
}

            

        

            

                4238
            

            

                
            

            

                

            

        

            

                4239
            

            

                
            

            

                
// Generated as internal constructor for term uload16x4.

            

        

            

                4240
            

            

                
            

            

                
pub fn constructor_uload16x4<C: Context>(

            

        

            

                4241
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4242
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4243
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                4244
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4245
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                4246
            

            

                
            

            

                
) -> Value {

            

        

            

                4247
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                4248
            

            

                
            

            

                
        opcode: Opcode::Uload16x4,

            

        

            

                4249
            

            

                
            

            

                
        arg: arg2,

            

        

            

                4250
            

            

                
            

            

                
        flags: arg1,

            

        

            

                4251
            

            

                
            

            

                
        offset: arg3,

            

        

            

                4252
            

            

                
            

            

                
    };

            

        

            

                4253
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4254
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 576.

            

        

            

                4255
            

            

                
            

            

                
    return v6;

            

        

            

                4256
            

            

                
            

            

                
}

            

        

            

                4257
            

            

                
            

            

                

            

        

            

                4258
            

            

                
            

            

                
// Generated as internal constructor for term sload16x4.

            

        

            

                4259
            

            

                
            

            

                
pub fn constructor_sload16x4<C: Context>(

            

        

            

                4260
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4261
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4262
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                4263
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4264
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                4265
            

            

                
            

            

                
) -> Value {

            

        

            

                4266
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                4267
            

            

                
            

            

                
        opcode: Opcode::Sload16x4,

            

        

            

                4268
            

            

                
            

            

                
        arg: arg2,

            

        

            

                4269
            

            

                
            

            

                
        flags: arg1,

            

        

            

                4270
            

            

                
            

            

                
        offset: arg3,

            

        

            

                4271
            

            

                
            

            

                
    };

            

        

            

                4272
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4273
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 585.

            

        

            

                4274
            

            

                
            

            

                
    return v6;

            

        

            

                4275
            

            

                
            

            

                
}

            

        

            

                4276
            

            

                
            

            

                

            

        

            

                4277
            

            

                
            

            

                
// Generated as internal constructor for term uload32x2.

            

        

            

                4278
            

            

                
            

            

                
pub fn constructor_uload32x2<C: Context>(

            

        

            

                4279
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4280
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4281
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                4282
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4283
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                4284
            

            

                
            

            

                
) -> Value {

            

        

            

                4285
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                4286
            

            

                
            

            

                
        opcode: Opcode::Uload32x2,

            

        

            

                4287
            

            

                
            

            

                
        arg: arg2,

            

        

            

                4288
            

            

                
            

            

                
        flags: arg1,

            

        

            

                4289
            

            

                
            

            

                
        offset: arg3,

            

        

            

                4290
            

            

                
            

            

                
    };

            

        

            

                4291
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4292
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 594.

            

        

            

                4293
            

            

                
            

            

                
    return v6;

            

        

            

                4294
            

            

                
            

            

                
}

            

        

            

                4295
            

            

                
            

            

                

            

        

            

                4296
            

            

                
            

            

                
// Generated as internal constructor for term sload32x2.

            

        

            

                4297
            

            

                
            

            

                
pub fn constructor_sload32x2<C: Context>(

            

        

            

                4298
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4299
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4300
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                4301
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4302
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                4303
            

            

                
            

            

                
) -> Value {

            

        

            

                4304
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                4305
            

            

                
            

            

                
        opcode: Opcode::Sload32x2,

            

        

            

                4306
            

            

                
            

            

                
        arg: arg2,

            

        

            

                4307
            

            

                
            

            

                
        flags: arg1,

            

        

            

                4308
            

            

                
            

            

                
        offset: arg3,

            

        

            

                4309
            

            

                
            

            

                
    };

            

        

            

                4310
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4311
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 603.

            

        

            

                4312
            

            

                
            

            

                
    return v6;

            

        

            

                4313
            

            

                
            

            

                
}

            

        

            

                4314
            

            

                
            

            

                

            

        

            

                4315
            

            

                
            

            

                
// Generated as internal constructor for term stack_load.

            

        

            

                4316
            

            

                
            

            

                
pub fn constructor_stack_load<C: Context>(

            

        

            

                4317
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4318
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4319
            

            

                
            

            

                
    arg1: StackSlot,

            

        

            

                4320
            

            

                
            

            

                
    arg2: Offset32,

            

        

            

                4321
            

            

                
            

            

                
) -> Value {

            

        

            

                4322
            

            

                
            

            

                
    let v4 = InstructionData::StackLoad {

            

        

            

                4323
            

            

                
            

            

                
        opcode: Opcode::StackLoad,

            

        

            

                4324
            

            

                
            

            

                
        stack_slot: arg1,

            

        

            

                4325
            

            

                
            

            

                
        offset: arg2,

            

        

            

                4326
            

            

                
            

            

                
    };

            

        

            

                4327
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                4328
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 612.

            

        

            

                4329
            

            

                
            

            

                
    return v5;

            

        

            

                4330
            

            

                
            

            

                
}

            

        

            

                4331
            

            

                
            

            

                

            

        

            

                4332
            

            

                
            

            

                
// Generated as internal constructor for term stack_addr.

            

        

            

                4333
            

            

                
            

            

                
pub fn constructor_stack_addr<C: Context>(

            

        

            

                4334
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4335
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4336
            

            

                
            

            

                
    arg1: StackSlot,

            

        

            

                4337
            

            

                
            

            

                
    arg2: Offset32,

            

        

            

                4338
            

            

                
            

            

                
) -> Value {

            

        

            

                4339
            

            

                
            

            

                
    let v4 = InstructionData::StackLoad {

            

        

            

                4340
            

            

                
            

            

                
        opcode: Opcode::StackAddr,

            

        

            

                4341
            

            

                
            

            

                
        stack_slot: arg1,

            

        

            

                4342
            

            

                
            

            

                
        offset: arg2,

            

        

            

                4343
            

            

                
            

            

                
    };

            

        

            

                4344
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                4345
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 621.

            

        

            

                4346
            

            

                
            

            

                
    return v5;

            

        

            

                4347
            

            

                
            

            

                
}

            

        

            

                4348
            

            

                
            

            

                

            

        

            

                4349
            

            

                
            

            

                
// Generated as internal constructor for term dynamic_stack_load.

            

        

            

                4350
            

            

                
            

            

                
pub fn constructor_dynamic_stack_load<C: Context>(

            

        

            

                4351
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4352
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4353
            

            

                
            

            

                
    arg1: DynamicStackSlot,

            

        

            

                4354
            

            

                
            

            

                
) -> Value {

            

        

            

                4355
            

            

                
            

            

                
    let v3 = InstructionData::DynamicStackLoad {

            

        

            

                4356
            

            

                
            

            

                
        opcode: Opcode::DynamicStackLoad,

            

        

            

                4357
            

            

                
            

            

                
        dynamic_stack_slot: arg1,

            

        

            

                4358
            

            

                
            

            

                
    };

            

        

            

                4359
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                4360
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 630.

            

        

            

                4361
            

            

                
            

            

                
    return v4;

            

        

            

                4362
            

            

                
            

            

                
}

            

        

            

                4363
            

            

                
            

            

                

            

        

            

                4364
            

            

                
            

            

                
// Generated as internal constructor for term dynamic_stack_addr.

            

        

            

                4365
            

            

                
            

            

                
pub fn constructor_dynamic_stack_addr<C: Context>(

            

        

            

                4366
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4367
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4368
            

            

                
            

            

                
    arg1: DynamicStackSlot,

            

        

            

                4369
            

            

                
            

            

                
) -> Value {

            

        

            

                4370
            

            

                
            

            

                
    let v3 = InstructionData::DynamicStackLoad {

            

        

            

                4371
            

            

                
            

            

                
        opcode: Opcode::DynamicStackAddr,

            

        

            

                4372
            

            

                
            

            

                
        dynamic_stack_slot: arg1,

            

        

            

                4373
            

            

                
            

            

                
    };

            

        

            

                4374
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                4375
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 639.

            

        

            

                4376
            

            

                
            

            

                
    return v4;

            

        

            

                4377
            

            

                
            

            

                
}

            

        

            

                4378
            

            

                
            

            

                

            

        

            

                4379
            

            

                
            

            

                
// Generated as internal constructor for term global_value.

            

        

            

                4380
            

            

                
            

            

                
pub fn constructor_global_value<C: Context>(ctx: &mut C, arg0: Type, arg1: GlobalValue) -> Value {

            

        

            

                4381
            

            

                
            

            

                
    let v3 = InstructionData::UnaryGlobalValue {

            

        

            

                4382
            

            

                
            

            

                
        opcode: Opcode::GlobalValue,

            

        

            

                4383
            

            

                
            

            

                
        global_value: arg1,

            

        

            

                4384
            

            

                
            

            

                
    };

            

        

            

                4385
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                4386
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 648.

            

        

            

                4387
            

            

                
            

            

                
    return v4;

            

        

            

                4388
            

            

                
            

            

                
}

            

        

            

                4389
            

            

                
            

            

                

            

        

            

                4390
            

            

                
            

            

                
// Generated as internal constructor for term symbol_value.

            

        

            

                4391
            

            

                
            

            

                
pub fn constructor_symbol_value<C: Context>(ctx: &mut C, arg0: Type, arg1: GlobalValue) -> Value {

            

        

            

                4392
            

            

                
            

            

                
    let v3 = InstructionData::UnaryGlobalValue {

            

        

            

                4393
            

            

                
            

            

                
        opcode: Opcode::SymbolValue,

            

        

            

                4394
            

            

                
            

            

                
        global_value: arg1,

            

        

            

                4395
            

            

                
            

            

                
    };

            

        

            

                4396
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                4397
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 657.

            

        

            

                4398
            

            

                
            

            

                
    return v4;

            

        

            

                4399
            

            

                
            

            

                
}

            

        

            

                4400
            

            

                
            

            

                

            

        

            

                4401
            

            

                
            

            

                
// Generated as internal constructor for term tls_value.

            

        

            

                4402
            

            

                
            

            

                
pub fn constructor_tls_value<C: Context>(ctx: &mut C, arg0: Type, arg1: GlobalValue) -> Value {

            

        

            

                4403
            

            

                
            

            

                
    let v3 = InstructionData::UnaryGlobalValue {

            

        

            

                4404
            

            

                
            

            

                
        opcode: Opcode::TlsValue,

            

        

            

                4405
            

            

                
            

            

                
        global_value: arg1,

            

        

            

                4406
            

            

                
            

            

                
    };

            

        

            

                4407
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                4408
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 666.

            

        

            

                4409
            

            

                
            

            

                
    return v4;

            

        

            

                4410
            

            

                
            

            

                
}

            

        

            

                4411
            

            

                
            

            

                

            

        

            

                4412
            

            

                
            

            

                
// Generated as internal constructor for term get_pinned_reg.

            

        

            

                4413
            

            

                
            

            

                
pub fn constructor_get_pinned_reg<C: Context>(ctx: &mut C, arg0: Type) -> Value {

            

        

            

                4414
            

            

                
            

            

                
    let v2 = InstructionData::NullAry {

            

        

            

                4415
            

            

                
            

            

                
        opcode: Opcode::GetPinnedReg,

            

        

            

                4416
            

            

                
            

            

                
    };

            

        

            

                4417
            

            

                
            

            

                
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);

            

        

            

                4418
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 675.

            

        

            

                4419
            

            

                
            

            

                
    return v3;

            

        

            

                4420
            

            

                
            

            

                
}

            

        

            

                4421
            

            

                
            

            

                

            

        

            

                4422
            

            

                
            

            

                
// Generated as internal constructor for term get_frame_pointer.

            

        

            

                4423
            

            

                
            

            

                
pub fn constructor_get_frame_pointer<C: Context>(ctx: &mut C, arg0: Type) -> Value {

            

        

            

                4424
            

            

                
            

            

                
    let v2 = InstructionData::NullAry {

            

        

            

                4425
            

            

                
            

            

                
        opcode: Opcode::GetFramePointer,

            

        

            

                4426
            

            

                
            

            

                
    };

            

        

            

                4427
            

            

                
            

            

                
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);

            

        

            

                4428
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 684.

            

        

            

                4429
            

            

                
            

            

                
    return v3;

            

        

            

                4430
            

            

                
            

            

                
}

            

        

            

                4431
            

            

                
            

            

                

            

        

            

                4432
            

            

                
            

            

                
// Generated as internal constructor for term get_stack_pointer.

            

        

            

                4433
            

            

                
            

            

                
pub fn constructor_get_stack_pointer<C: Context>(ctx: &mut C, arg0: Type) -> Value {

            

        

            

                4434
            

            

                
            

            

                
    let v2 = InstructionData::NullAry {

            

        

            

                4435
            

            

                
            

            

                
        opcode: Opcode::GetStackPointer,

            

        

            

                4436
            

            

                
            

            

                
    };

            

        

            

                4437
            

            

                
            

            

                
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);

            

        

            

                4438
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 693.

            

        

            

                4439
            

            

                
            

            

                
    return v3;

            

        

            

                4440
            

            

                
            

            

                
}

            

        

            

                4441
            

            

                
            

            

                

            

        

            

                4442
            

            

                
            

            

                
// Generated as internal constructor for term get_return_address.

            

        

            

                4443
            

            

                
            

            

                
pub fn constructor_get_return_address<C: Context>(ctx: &mut C, arg0: Type) -> Value {

            

        

            

                4444
            

            

                
            

            

                
    let v2 = InstructionData::NullAry {

            

        

            

                4445
            

            

                
            

            

                
        opcode: Opcode::GetReturnAddress,

            

        

            

                4446
            

            

                
            

            

                
    };

            

        

            

                4447
            

            

                
            

            

                
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);

            

        

            

                4448
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 702.

            

        

            

                4449
            

            

                
            

            

                
    return v3;

            

        

            

                4450
            

            

                
            

            

                
}

            

        

            

                4451
            

            

                
            

            

                

            

        

            

                4452
            

            

                
            

            

                
// Generated as internal constructor for term table_addr.

            

        

            

                4453
            

            

                
            

            

                
pub fn constructor_table_addr<C: Context>(

            

        

            

                4454
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4455
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4456
            

            

                
            

            

                
    arg1: Table,

            

        

            

                4457
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4458
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                4459
            

            

                
            

            

                
) -> Value {

            

        

            

                4460
            

            

                
            

            

                
    let v5 = InstructionData::TableAddr {

            

        

            

                4461
            

            

                
            

            

                
        opcode: Opcode::TableAddr,

            

        

            

                4462
            

            

                
            

            

                
        arg: arg2,

            

        

            

                4463
            

            

                
            

            

                
        table: arg1,

            

        

            

                4464
            

            

                
            

            

                
        offset: arg3,

            

        

            

                4465
            

            

                
            

            

                
    };

            

        

            

                4466
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4467
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 711.

            

        

            

                4468
            

            

                
            

            

                
    return v6;

            

        

            

                4469
            

            

                
            

            

                
}

            

        

            

                4470
            

            

                
            

            

                

            

        

            

                4471
            

            

                
            

            

                
// Generated as internal constructor for term iconst.

            

        

            

                4472
            

            

                
            

            

                
pub fn constructor_iconst<C: Context>(ctx: &mut C, arg0: Type, arg1: Imm64) -> Value {

            

        

            

                4473
            

            

                
            

            

                
    let v3 = InstructionData::UnaryImm {

            

        

            

                4474
            

            

                
            

            

                
        opcode: Opcode::Iconst,

            

        

            

                4475
            

            

                
            

            

                
        imm: arg1,

            

        

            

                4476
            

            

                
            

            

                
    };

            

        

            

                4477
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                4478
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 720.

            

        

            

                4479
            

            

                
            

            

                
    return v4;

            

        

            

                4480
            

            

                
            

            

                
}

            

        

            

                4481
            

            

                
            

            

                

            

        

            

                4482
            

            

                
            

            

                
// Generated as internal constructor for term f32const.

            

        

            

                4483
            

            

                
            

            

                
pub fn constructor_f32const<C: Context>(ctx: &mut C, arg0: Type, arg1: Ieee32) -> Value {

            

        

            

                4484
            

            

                
            

            

                
    let v3 = InstructionData::UnaryIeee32 {

            

        

            

                4485
            

            

                
            

            

                
        opcode: Opcode::F32const,

            

        

            

                4486
            

            

                
            

            

                
        imm: arg1,

            

        

            

                4487
            

            

                
            

            

                
    };

            

        

            

                4488
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                4489
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 729.

            

        

            

                4490
            

            

                
            

            

                
    return v4;

            

        

            

                4491
            

            

                
            

            

                
}

            

        

            

                4492
            

            

                
            

            

                

            

        

            

                4493
            

            

                
            

            

                
// Generated as internal constructor for term f64const.

            

        

            

                4494
            

            

                
            

            

                
pub fn constructor_f64const<C: Context>(ctx: &mut C, arg0: Type, arg1: Ieee64) -> Value {

            

        

            

                4495
            

            

                
            

            

                
    let v3 = InstructionData::UnaryIeee64 {

            

        

            

                4496
            

            

                
            

            

                
        opcode: Opcode::F64const,

            

        

            

                4497
            

            

                
            

            

                
        imm: arg1,

            

        

            

                4498
            

            

                
            

            

                
    };

            

        

            

                4499
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                4500
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 738.

            

        

            

                4501
            

            

                
            

            

                
    return v4;

            

        

            

                4502
            

            

                
            

            

                
}

            

        

            

                4503
            

            

                
            

            

                

            

        

            

                4504
            

            

                
            

            

                
// Generated as internal constructor for term vconst.

            

        

            

                4505
            

            

                
            

            

                
pub fn constructor_vconst<C: Context>(ctx: &mut C, arg0: Type, arg1: Constant) -> Value {

            

        

            

                4506
            

            

                
            

            

                
    let v3 = InstructionData::UnaryConst {

            

        

            

                4507
            

            

                
            

            

                
        opcode: Opcode::Vconst,

            

        

            

                4508
            

            

                
            

            

                
        constant_handle: arg1,

            

        

            

                4509
            

            

                
            

            

                
    };

            

        

            

                4510
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                4511
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 747.

            

        

            

                4512
            

            

                
            

            

                
    return v4;

            

        

            

                4513
            

            

                
            

            

                
}

            

        

            

                4514
            

            

                
            

            

                

            

        

            

                4515
            

            

                
            

            

                
// Generated as internal constructor for term shuffle.

            

        

            

                4516
            

            

                
            

            

                
pub fn constructor_shuffle<C: Context>(

            

        

            

                4517
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4518
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4519
            

            

                
            

            

                
    arg1: Value,

            

        

            

                4520
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4521
            

            

                
            

            

                
    arg3: Immediate,

            

        

            

                4522
            

            

                
            

            

                
) -> Value {

            

        

            

                4523
            

            

                
            

            

                
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                4524
            

            

                
            

            

                
    let v6 = InstructionData::Shuffle {

            

        

            

                4525
            

            

                
            

            

                
        opcode: Opcode::Shuffle,

            

        

            

                4526
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                4527
            

            

                
            

            

                
        imm: arg3,

            

        

            

                4528
            

            

                
            

            

                
    };

            

        

            

                4529
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                4530
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 756.

            

        

            

                4531
            

            

                
            

            

                
    return v7;

            

        

            

                4532
            

            

                
            

            

                
}

            

        

            

                4533
            

            

                
            

            

                

            

        

            

                4534
            

            

                
            

            

                
// Generated as internal constructor for term null.

            

        

            

                4535
            

            

                
            

            

                
pub fn constructor_null<C: Context>(ctx: &mut C, arg0: Type) -> Value {

            

        

            

                4536
            

            

                
            

            

                
    let v2 = InstructionData::NullAry {

            

        

            

                4537
            

            

                
            

            

                
        opcode: Opcode::Null,

            

        

            

                4538
            

            

                
            

            

                
    };

            

        

            

                4539
            

            

                
            

            

                
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);

            

        

            

                4540
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 765.

            

        

            

                4541
            

            

                
            

            

                
    return v3;

            

        

            

                4542
            

            

                
            

            

                
}

            

        

            

                4543
            

            

                
            

            

                

            

        

            

                4544
            

            

                
            

            

                
// Generated as internal constructor for term select.

            

        

            

                4545
            

            

                
            

            

                
pub fn constructor_select<C: Context>(

            

        

            

                4546
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4547
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4548
            

            

                
            

            

                
    arg1: Value,

            

        

            

                4549
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4550
            

            

                
            

            

                
    arg3: Value,

            

        

            

                4551
            

            

                
            

            

                
) -> Value {

            

        

            

                4552
            

            

                
            

            

                
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);

            

        

            

                4553
            

            

                
            

            

                
    let v6 = InstructionData::Ternary {

            

        

            

                4554
            

            

                
            

            

                
        opcode: Opcode::Select,

            

        

            

                4555
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                4556
            

            

                
            

            

                
    };

            

        

            

                4557
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                4558
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 774.

            

        

            

                4559
            

            

                
            

            

                
    return v7;

            

        

            

                4560
            

            

                
            

            

                
}

            

        

            

                4561
            

            

                
            

            

                

            

        

            

                4562
            

            

                
            

            

                
// Generated as internal constructor for term select_spectre_guard.

            

        

            

                4563
            

            

                
            

            

                
pub fn constructor_select_spectre_guard<C: Context>(

            

        

            

                4564
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4565
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4566
            

            

                
            

            

                
    arg1: Value,

            

        

            

                4567
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4568
            

            

                
            

            

                
    arg3: Value,

            

        

            

                4569
            

            

                
            

            

                
) -> Value {

            

        

            

                4570
            

            

                
            

            

                
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);

            

        

            

                4571
            

            

                
            

            

                
    let v6 = InstructionData::Ternary {

            

        

            

                4572
            

            

                
            

            

                
        opcode: Opcode::SelectSpectreGuard,

            

        

            

                4573
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                4574
            

            

                
            

            

                
    };

            

        

            

                4575
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                4576
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 783.

            

        

            

                4577
            

            

                
            

            

                
    return v7;

            

        

            

                4578
            

            

                
            

            

                
}

            

        

            

                4579
            

            

                
            

            

                

            

        

            

                4580
            

            

                
            

            

                
// Generated as internal constructor for term bitselect.

            

        

            

                4581
            

            

                
            

            

                
pub fn constructor_bitselect<C: Context>(

            

        

            

                4582
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4583
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4584
            

            

                
            

            

                
    arg1: Value,

            

        

            

                4585
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4586
            

            

                
            

            

                
    arg3: Value,

            

        

            

                4587
            

            

                
            

            

                
) -> Value {

            

        

            

                4588
            

            

                
            

            

                
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);

            

        

            

                4589
            

            

                
            

            

                
    let v6 = InstructionData::Ternary {

            

        

            

                4590
            

            

                
            

            

                
        opcode: Opcode::Bitselect,

            

        

            

                4591
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                4592
            

            

                
            

            

                
    };

            

        

            

                4593
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                4594
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 792.

            

        

            

                4595
            

            

                
            

            

                
    return v7;

            

        

            

                4596
            

            

                
            

            

                
}

            

        

            

                4597
            

            

                
            

            

                

            

        

            

                4598
            

            

                
            

            

                
// Generated as internal constructor for term x86_blendv.

            

        

            

                4599
            

            

                
            

            

                
pub fn constructor_x86_blendv<C: Context>(

            

        

            

                4600
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4601
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4602
            

            

                
            

            

                
    arg1: Value,

            

        

            

                4603
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4604
            

            

                
            

            

                
    arg3: Value,

            

        

            

                4605
            

            

                
            

            

                
) -> Value {

            

        

            

                4606
            

            

                
            

            

                
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);

            

        

            

                4607
            

            

                
            

            

                
    let v6 = InstructionData::Ternary {

            

        

            

                4608
            

            

                
            

            

                
        opcode: Opcode::X86Blendv,

            

        

            

                4609
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                4610
            

            

                
            

            

                
    };

            

        

            

                4611
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                4612
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 801.

            

        

            

                4613
            

            

                
            

            

                
    return v7;

            

        

            

                4614
            

            

                
            

            

                
}

            

        

            

                4615
            

            

                
            

            

                

            

        

            

                4616
            

            

                
            

            

                
// Generated as internal constructor for term vany_true.

            

        

            

                4617
            

            

                
            

            

                
pub fn constructor_vany_true<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                4618
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                4619
            

            

                
            

            

                
        opcode: Opcode::VanyTrue,

            

        

            

                4620
            

            

                
            

            

                
        arg: arg1,

            

        

            

                4621
            

            

                
            

            

                
    };

            

        

            

                4622
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                4623
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 810.

            

        

            

                4624
            

            

                
            

            

                
    return v4;

            

        

            

                4625
            

            

                
            

            

                
}

            

        

            

                4626
            

            

                
            

            

                

            

        

            

                4627
            

            

                
            

            

                
// Generated as internal constructor for term vall_true.

            

        

            

                4628
            

            

                
            

            

                
pub fn constructor_vall_true<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                4629
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                4630
            

            

                
            

            

                
        opcode: Opcode::VallTrue,

            

        

            

                4631
            

            

                
            

            

                
        arg: arg1,

            

        

            

                4632
            

            

                
            

            

                
    };

            

        

            

                4633
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                4634
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 819.

            

        

            

                4635
            

            

                
            

            

                
    return v4;

            

        

            

                4636
            

            

                
            

            

                
}

            

        

            

                4637
            

            

                
            

            

                

            

        

            

                4638
            

            

                
            

            

                
// Generated as internal constructor for term vhigh_bits.

            

        

            

                4639
            

            

                
            

            

                
pub fn constructor_vhigh_bits<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                4640
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                4641
            

            

                
            

            

                
        opcode: Opcode::VhighBits,

            

        

            

                4642
            

            

                
            

            

                
        arg: arg1,

            

        

            

                4643
            

            

                
            

            

                
    };

            

        

            

                4644
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                4645
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 828.

            

        

            

                4646
            

            

                
            

            

                
    return v4;

            

        

            

                4647
            

            

                
            

            

                
}

            

        

            

                4648
            

            

                
            

            

                

            

        

            

                4649
            

            

                
            

            

                
// Generated as internal constructor for term icmp.

            

        

            

                4650
            

            

                
            

            

                
pub fn constructor_icmp<C: Context>(

            

        

            

                4651
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4652
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4653
            

            

                
            

            

                
    arg1: &IntCC,

            

        

            

                4654
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4655
            

            

                
            

            

                
    arg3: Value,

            

        

            

                4656
            

            

                
            

            

                
) -> Value {

            

        

            

                4657
            

            

                
            

            

                
    let v5 = &C::value_array_2_ctor(ctx, arg2, arg3);

            

        

            

                4658
            

            

                
            

            

                
    let v6 = InstructionData::IntCompare {

            

        

            

                4659
            

            

                
            

            

                
        opcode: Opcode::Icmp,

            

        

            

                4660
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                4661
            

            

                
            

            

                
        cond: arg1.clone(),

            

        

            

                4662
            

            

                
            

            

                
    };

            

        

            

                4663
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                4664
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 837.

            

        

            

                4665
            

            

                
            

            

                
    return v7;

            

        

            

                4666
            

            

                
            

            

                
}

            

        

            

                4667
            

            

                
            

            

                

            

        

            

                4668
            

            

                
            

            

                
// Generated as internal constructor for term icmp_imm.

            

        

            

                4669
            

            

                
            

            

                
pub fn constructor_icmp_imm<C: Context>(

            

        

            

                4670
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4671
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4672
            

            

                
            

            

                
    arg1: &IntCC,

            

        

            

                4673
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4674
            

            

                
            

            

                
    arg3: Imm64,

            

        

            

                4675
            

            

                
            

            

                
) -> Value {

            

        

            

                4676
            

            

                
            

            

                
    let v5 = InstructionData::IntCompareImm {

            

        

            

                4677
            

            

                
            

            

                
        opcode: Opcode::IcmpImm,

            

        

            

                4678
            

            

                
            

            

                
        arg: arg2,

            

        

            

                4679
            

            

                
            

            

                
        cond: arg1.clone(),

            

        

            

                4680
            

            

                
            

            

                
        imm: arg3,

            

        

            

                4681
            

            

                
            

            

                
    };

            

        

            

                4682
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4683
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 846.

            

        

            

                4684
            

            

                
            

            

                
    return v6;

            

        

            

                4685
            

            

                
            

            

                
}

            

        

            

                4686
            

            

                
            

            

                

            

        

            

                4687
            

            

                
            

            

                
// Generated as internal constructor for term iadd.

            

        

            

                4688
            

            

                
            

            

                
pub fn constructor_iadd<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                4689
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                4690
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                4691
            

            

                
            

            

                
        opcode: Opcode::Iadd,

            

        

            

                4692
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                4693
            

            

                
            

            

                
    };

            

        

            

                4694
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4695
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 855.

            

        

            

                4696
            

            

                
            

            

                
    return v6;

            

        

            

                4697
            

            

                
            

            

                
}

            

        

            

                4698
            

            

                
            

            

                

            

        

            

                4699
            

            

                
            

            

                
// Generated as internal constructor for term isub.

            

        

            

                4700
            

            

                
            

            

                
pub fn constructor_isub<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                4701
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                4702
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                4703
            

            

                
            

            

                
        opcode: Opcode::Isub,

            

        

            

                4704
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                4705
            

            

                
            

            

                
    };

            

        

            

                4706
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4707
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 864.

            

        

            

                4708
            

            

                
            

            

                
    return v6;

            

        

            

                4709
            

            

                
            

            

                
}

            

        

            

                4710
            

            

                
            

            

                

            

        

            

                4711
            

            

                
            

            

                
// Generated as internal constructor for term ineg.

            

        

            

                4712
            

            

                
            

            

                
pub fn constructor_ineg<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                4713
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                4714
            

            

                
            

            

                
        opcode: Opcode::Ineg,

            

        

            

                4715
            

            

                
            

            

                
        arg: arg1,

            

        

            

                4716
            

            

                
            

            

                
    };

            

        

            

                4717
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                4718
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 873.

            

        

            

                4719
            

            

                
            

            

                
    return v4;

            

        

            

                4720
            

            

                
            

            

                
}

            

        

            

                4721
            

            

                
            

            

                

            

        

            

                4722
            

            

                
            

            

                
// Generated as internal constructor for term iabs.

            

        

            

                4723
            

            

                
            

            

                
pub fn constructor_iabs<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                4724
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                4725
            

            

                
            

            

                
        opcode: Opcode::Iabs,

            

        

            

                4726
            

            

                
            

            

                
        arg: arg1,

            

        

            

                4727
            

            

                
            

            

                
    };

            

        

            

                4728
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                4729
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 882.

            

        

            

                4730
            

            

                
            

            

                
    return v4;

            

        

            

                4731
            

            

                
            

            

                
}

            

        

            

                4732
            

            

                
            

            

                

            

        

            

                4733
            

            

                
            

            

                
// Generated as internal constructor for term imul.

            

        

            

                4734
            

            

                
            

            

                
pub fn constructor_imul<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                4735
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                4736
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                4737
            

            

                
            

            

                
        opcode: Opcode::Imul,

            

        

            

                4738
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                4739
            

            

                
            

            

                
    };

            

        

            

                4740
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4741
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 891.

            

        

            

                4742
            

            

                
            

            

                
    return v6;

            

        

            

                4743
            

            

                
            

            

                
}

            

        

            

                4744
            

            

                
            

            

                

            

        

            

                4745
            

            

                
            

            

                
// Generated as internal constructor for term umulhi.

            

        

            

                4746
            

            

                
            

            

                
pub fn constructor_umulhi<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                4747
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                4748
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                4749
            

            

                
            

            

                
        opcode: Opcode::Umulhi,

            

        

            

                4750
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                4751
            

            

                
            

            

                
    };

            

        

            

                4752
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4753
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 900.

            

        

            

                4754
            

            

                
            

            

                
    return v6;

            

        

            

                4755
            

            

                
            

            

                
}

            

        

            

                4756
            

            

                
            

            

                

            

        

            

                4757
            

            

                
            

            

                
// Generated as internal constructor for term smulhi.

            

        

            

                4758
            

            

                
            

            

                
pub fn constructor_smulhi<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                4759
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                4760
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                4761
            

            

                
            

            

                
        opcode: Opcode::Smulhi,

            

        

            

                4762
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                4763
            

            

                
            

            

                
    };

            

        

            

                4764
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4765
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 909.

            

        

            

                4766
            

            

                
            

            

                
    return v6;

            

        

            

                4767
            

            

                
            

            

                
}

            

        

            

                4768
            

            

                
            

            

                

            

        

            

                4769
            

            

                
            

            

                
// Generated as internal constructor for term sqmul_round_sat.

            

        

            

                4770
            

            

                
            

            

                
pub fn constructor_sqmul_round_sat<C: Context>(

            

        

            

                4771
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4772
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4773
            

            

                
            

            

                
    arg1: Value,

            

        

            

                4774
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4775
            

            

                
            

            

                
) -> Value {

            

        

            

                4776
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                4777
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                4778
            

            

                
            

            

                
        opcode: Opcode::SqmulRoundSat,

            

        

            

                4779
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                4780
            

            

                
            

            

                
    };

            

        

            

                4781
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4782
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 918.

            

        

            

                4783
            

            

                
            

            

                
    return v6;

            

        

            

                4784
            

            

                
            

            

                
}

            

        

            

                4785
            

            

                
            

            

                

            

        

            

                4786
            

            

                
            

            

                
// Generated as internal constructor for term x86_pmulhrsw.

            

        

            

                4787
            

            

                
            

            

                
pub fn constructor_x86_pmulhrsw<C: Context>(

            

        

            

                4788
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4789
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4790
            

            

                
            

            

                
    arg1: Value,

            

        

            

                4791
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4792
            

            

                
            

            

                
) -> Value {

            

        

            

                4793
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                4794
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                4795
            

            

                
            

            

                
        opcode: Opcode::X86Pmulhrsw,

            

        

            

                4796
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                4797
            

            

                
            

            

                
    };

            

        

            

                4798
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4799
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 927.

            

        

            

                4800
            

            

                
            

            

                
    return v6;

            

        

            

                4801
            

            

                
            

            

                
}

            

        

            

                4802
            

            

                
            

            

                

            

        

            

                4803
            

            

                
            

            

                
// Generated as internal constructor for term udiv.

            

        

            

                4804
            

            

                
            

            

                
pub fn constructor_udiv<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                4805
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                4806
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                4807
            

            

                
            

            

                
        opcode: Opcode::Udiv,

            

        

            

                4808
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                4809
            

            

                
            

            

                
    };

            

        

            

                4810
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4811
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 936.

            

        

            

                4812
            

            

                
            

            

                
    return v6;

            

        

            

                4813
            

            

                
            

            

                
}

            

        

            

                4814
            

            

                
            

            

                

            

        

            

                4815
            

            

                
            

            

                
// Generated as internal constructor for term sdiv.

            

        

            

                4816
            

            

                
            

            

                
pub fn constructor_sdiv<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                4817
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                4818
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                4819
            

            

                
            

            

                
        opcode: Opcode::Sdiv,

            

        

            

                4820
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                4821
            

            

                
            

            

                
    };

            

        

            

                4822
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4823
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 945.

            

        

            

                4824
            

            

                
            

            

                
    return v6;

            

        

            

                4825
            

            

                
            

            

                
}

            

        

            

                4826
            

            

                
            

            

                

            

        

            

                4827
            

            

                
            

            

                
// Generated as internal constructor for term urem.

            

        

            

                4828
            

            

                
            

            

                
pub fn constructor_urem<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                4829
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                4830
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                4831
            

            

                
            

            

                
        opcode: Opcode::Urem,

            

        

            

                4832
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                4833
            

            

                
            

            

                
    };

            

        

            

                4834
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4835
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 954.

            

        

            

                4836
            

            

                
            

            

                
    return v6;

            

        

            

                4837
            

            

                
            

            

                
}

            

        

            

                4838
            

            

                
            

            

                

            

        

            

                4839
            

            

                
            

            

                
// Generated as internal constructor for term srem.

            

        

            

                4840
            

            

                
            

            

                
pub fn constructor_srem<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                4841
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                4842
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                4843
            

            

                
            

            

                
        opcode: Opcode::Srem,

            

        

            

                4844
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                4845
            

            

                
            

            

                
    };

            

        

            

                4846
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                4847
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 963.

            

        

            

                4848
            

            

                
            

            

                
    return v6;

            

        

            

                4849
            

            

                
            

            

                
}

            

        

            

                4850
            

            

                
            

            

                

            

        

            

                4851
            

            

                
            

            

                
// Generated as internal constructor for term iadd_imm.

            

        

            

                4852
            

            

                
            

            

                
pub fn constructor_iadd_imm<C: Context>(

            

        

            

                4853
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4854
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4855
            

            

                
            

            

                
    arg1: Value,

            

        

            

                4856
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                4857
            

            

                
            

            

                
) -> Value {

            

        

            

                4858
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                4859
            

            

                
            

            

                
        opcode: Opcode::IaddImm,

            

        

            

                4860
            

            

                
            

            

                
        arg: arg1,

            

        

            

                4861
            

            

                
            

            

                
        imm: arg2,

            

        

            

                4862
            

            

                
            

            

                
    };

            

        

            

                4863
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                4864
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 972.

            

        

            

                4865
            

            

                
            

            

                
    return v5;

            

        

            

                4866
            

            

                
            

            

                
}

            

        

            

                4867
            

            

                
            

            

                

            

        

            

                4868
            

            

                
            

            

                
// Generated as internal constructor for term imul_imm.

            

        

            

                4869
            

            

                
            

            

                
pub fn constructor_imul_imm<C: Context>(

            

        

            

                4870
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4871
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4872
            

            

                
            

            

                
    arg1: Value,

            

        

            

                4873
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                4874
            

            

                
            

            

                
) -> Value {

            

        

            

                4875
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                4876
            

            

                
            

            

                
        opcode: Opcode::ImulImm,

            

        

            

                4877
            

            

                
            

            

                
        arg: arg1,

            

        

            

                4878
            

            

                
            

            

                
        imm: arg2,

            

        

            

                4879
            

            

                
            

            

                
    };

            

        

            

                4880
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                4881
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 981.

            

        

            

                4882
            

            

                
            

            

                
    return v5;

            

        

            

                4883
            

            

                
            

            

                
}

            

        

            

                4884
            

            

                
            

            

                

            

        

            

                4885
            

            

                
            

            

                
// Generated as internal constructor for term udiv_imm.

            

        

            

                4886
            

            

                
            

            

                
pub fn constructor_udiv_imm<C: Context>(

            

        

            

                4887
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4888
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4889
            

            

                
            

            

                
    arg1: Value,

            

        

            

                4890
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                4891
            

            

                
            

            

                
) -> Value {

            

        

            

                4892
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                4893
            

            

                
            

            

                
        opcode: Opcode::UdivImm,

            

        

            

                4894
            

            

                
            

            

                
        arg: arg1,

            

        

            

                4895
            

            

                
            

            

                
        imm: arg2,

            

        

            

                4896
            

            

                
            

            

                
    };

            

        

            

                4897
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                4898
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 990.

            

        

            

                4899
            

            

                
            

            

                
    return v5;

            

        

            

                4900
            

            

                
            

            

                
}

            

        

            

                4901
            

            

                
            

            

                

            

        

            

                4902
            

            

                
            

            

                
// Generated as internal constructor for term sdiv_imm.

            

        

            

                4903
            

            

                
            

            

                
pub fn constructor_sdiv_imm<C: Context>(

            

        

            

                4904
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4905
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4906
            

            

                
            

            

                
    arg1: Value,

            

        

            

                4907
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                4908
            

            

                
            

            

                
) -> Value {

            

        

            

                4909
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                4910
            

            

                
            

            

                
        opcode: Opcode::SdivImm,

            

        

            

                4911
            

            

                
            

            

                
        arg: arg1,

            

        

            

                4912
            

            

                
            

            

                
        imm: arg2,

            

        

            

                4913
            

            

                
            

            

                
    };

            

        

            

                4914
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                4915
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 999.

            

        

            

                4916
            

            

                
            

            

                
    return v5;

            

        

            

                4917
            

            

                
            

            

                
}

            

        

            

                4918
            

            

                
            

            

                

            

        

            

                4919
            

            

                
            

            

                
// Generated as internal constructor for term urem_imm.

            

        

            

                4920
            

            

                
            

            

                
pub fn constructor_urem_imm<C: Context>(

            

        

            

                4921
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4922
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4923
            

            

                
            

            

                
    arg1: Value,

            

        

            

                4924
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                4925
            

            

                
            

            

                
) -> Value {

            

        

            

                4926
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                4927
            

            

                
            

            

                
        opcode: Opcode::UremImm,

            

        

            

                4928
            

            

                
            

            

                
        arg: arg1,

            

        

            

                4929
            

            

                
            

            

                
        imm: arg2,

            

        

            

                4930
            

            

                
            

            

                
    };

            

        

            

                4931
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                4932
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1008.

            

        

            

                4933
            

            

                
            

            

                
    return v5;

            

        

            

                4934
            

            

                
            

            

                
}

            

        

            

                4935
            

            

                
            

            

                

            

        

            

                4936
            

            

                
            

            

                
// Generated as internal constructor for term srem_imm.

            

        

            

                4937
            

            

                
            

            

                
pub fn constructor_srem_imm<C: Context>(

            

        

            

                4938
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4939
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4940
            

            

                
            

            

                
    arg1: Value,

            

        

            

                4941
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                4942
            

            

                
            

            

                
) -> Value {

            

        

            

                4943
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                4944
            

            

                
            

            

                
        opcode: Opcode::SremImm,

            

        

            

                4945
            

            

                
            

            

                
        arg: arg1,

            

        

            

                4946
            

            

                
            

            

                
        imm: arg2,

            

        

            

                4947
            

            

                
            

            

                
    };

            

        

            

                4948
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                4949
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1017.

            

        

            

                4950
            

            

                
            

            

                
    return v5;

            

        

            

                4951
            

            

                
            

            

                
}

            

        

            

                4952
            

            

                
            

            

                

            

        

            

                4953
            

            

                
            

            

                
// Generated as internal constructor for term irsub_imm.

            

        

            

                4954
            

            

                
            

            

                
pub fn constructor_irsub_imm<C: Context>(

            

        

            

                4955
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4956
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4957
            

            

                
            

            

                
    arg1: Value,

            

        

            

                4958
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                4959
            

            

                
            

            

                
) -> Value {

            

        

            

                4960
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                4961
            

            

                
            

            

                
        opcode: Opcode::IrsubImm,

            

        

            

                4962
            

            

                
            

            

                
        arg: arg1,

            

        

            

                4963
            

            

                
            

            

                
        imm: arg2,

            

        

            

                4964
            

            

                
            

            

                
    };

            

        

            

                4965
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                4966
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1026.

            

        

            

                4967
            

            

                
            

            

                
    return v5;

            

        

            

                4968
            

            

                
            

            

                
}

            

        

            

                4969
            

            

                
            

            

                

            

        

            

                4970
            

            

                
            

            

                
// Generated as internal constructor for term iadd_cin.

            

        

            

                4971
            

            

                
            

            

                
pub fn constructor_iadd_cin<C: Context>(

            

        

            

                4972
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4973
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4974
            

            

                
            

            

                
    arg1: Value,

            

        

            

                4975
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4976
            

            

                
            

            

                
    arg3: Value,

            

        

            

                4977
            

            

                
            

            

                
) -> Value {

            

        

            

                4978
            

            

                
            

            

                
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);

            

        

            

                4979
            

            

                
            

            

                
    let v6 = InstructionData::Ternary {

            

        

            

                4980
            

            

                
            

            

                
        opcode: Opcode::IaddCin,

            

        

            

                4981
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                4982
            

            

                
            

            

                
    };

            

        

            

                4983
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                4984
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1035.

            

        

            

                4985
            

            

                
            

            

                
    return v7;

            

        

            

                4986
            

            

                
            

            

                
}

            

        

            

                4987
            

            

                
            

            

                

            

        

            

                4988
            

            

                
            

            

                
// Generated as internal constructor for term uadd_overflow_trap.

            

        

            

                4989
            

            

                
            

            

                
pub fn constructor_uadd_overflow_trap<C: Context>(

            

        

            

                4990
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4991
            

            

                
            

            

                
    arg0: Type,

            

        

            

                4992
            

            

                
            

            

                
    arg1: Value,

            

        

            

                4993
            

            

                
            

            

                
    arg2: Value,

            

        

            

                4994
            

            

                
            

            

                
    arg3: &TrapCode,

            

        

            

                4995
            

            

                
            

            

                
) -> Value {

            

        

            

                4996
            

            

                
            

            

                
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                4997
            

            

                
            

            

                
    let v6 = InstructionData::IntAddTrap {

            

        

            

                4998
            

            

                
            

            

                
        opcode: Opcode::UaddOverflowTrap,

            

        

            

                4999
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                5000
            

            

                
            

            

                
        code: arg3.clone(),

            

        

            

                5001
            

            

                
            

            

                
    };

            

        

            

                5002
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                5003
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1044.

            

        

            

                5004
            

            

                
            

            

                
    return v7;

            

        

            

                5005
            

            

                
            

            

                
}

            

        

            

                5006
            

            

                
            

            

                

            

        

            

                5007
            

            

                
            

            

                
// Generated as internal constructor for term isub_bin.

            

        

            

                5008
            

            

                
            

            

                
pub fn constructor_isub_bin<C: Context>(

            

        

            

                5009
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5010
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5011
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5012
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5013
            

            

                
            

            

                
    arg3: Value,

            

        

            

                5014
            

            

                
            

            

                
) -> Value {

            

        

            

                5015
            

            

                
            

            

                
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);

            

        

            

                5016
            

            

                
            

            

                
    let v6 = InstructionData::Ternary {

            

        

            

                5017
            

            

                
            

            

                
        opcode: Opcode::IsubBin,

            

        

            

                5018
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                5019
            

            

                
            

            

                
    };

            

        

            

                5020
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                5021
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1053.

            

        

            

                5022
            

            

                
            

            

                
    return v7;

            

        

            

                5023
            

            

                
            

            

                
}

            

        

            

                5024
            

            

                
            

            

                

            

        

            

                5025
            

            

                
            

            

                
// Generated as internal constructor for term band.

            

        

            

                5026
            

            

                
            

            

                
pub fn constructor_band<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5027
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5028
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5029
            

            

                
            

            

                
        opcode: Opcode::Band,

            

        

            

                5030
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5031
            

            

                
            

            

                
    };

            

        

            

                5032
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5033
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1062.

            

        

            

                5034
            

            

                
            

            

                
    return v6;

            

        

            

                5035
            

            

                
            

            

                
}

            

        

            

                5036
            

            

                
            

            

                

            

        

            

                5037
            

            

                
            

            

                
// Generated as internal constructor for term bor.

            

        

            

                5038
            

            

                
            

            

                
pub fn constructor_bor<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5039
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5040
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5041
            

            

                
            

            

                
        opcode: Opcode::Bor,

            

        

            

                5042
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5043
            

            

                
            

            

                
    };

            

        

            

                5044
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5045
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1071.

            

        

            

                5046
            

            

                
            

            

                
    return v6;

            

        

            

                5047
            

            

                
            

            

                
}

            

        

            

                5048
            

            

                
            

            

                

            

        

            

                5049
            

            

                
            

            

                
// Generated as internal constructor for term bxor.

            

        

            

                5050
            

            

                
            

            

                
pub fn constructor_bxor<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5051
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5052
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5053
            

            

                
            

            

                
        opcode: Opcode::Bxor,

            

        

            

                5054
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5055
            

            

                
            

            

                
    };

            

        

            

                5056
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5057
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1080.

            

        

            

                5058
            

            

                
            

            

                
    return v6;

            

        

            

                5059
            

            

                
            

            

                
}

            

        

            

                5060
            

            

                
            

            

                

            

        

            

                5061
            

            

                
            

            

                
// Generated as internal constructor for term bnot.

            

        

            

                5062
            

            

                
            

            

                
pub fn constructor_bnot<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5063
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5064
            

            

                
            

            

                
        opcode: Opcode::Bnot,

            

        

            

                5065
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5066
            

            

                
            

            

                
    };

            

        

            

                5067
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5068
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1089.

            

        

            

                5069
            

            

                
            

            

                
    return v4;

            

        

            

                5070
            

            

                
            

            

                
}

            

        

            

                5071
            

            

                
            

            

                

            

        

            

                5072
            

            

                
            

            

                
// Generated as internal constructor for term band_not.

            

        

            

                5073
            

            

                
            

            

                
pub fn constructor_band_not<C: Context>(

            

        

            

                5074
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5075
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5076
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5077
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5078
            

            

                
            

            

                
) -> Value {

            

        

            

                5079
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5080
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5081
            

            

                
            

            

                
        opcode: Opcode::BandNot,

            

        

            

                5082
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5083
            

            

                
            

            

                
    };

            

        

            

                5084
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5085
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1098.

            

        

            

                5086
            

            

                
            

            

                
    return v6;

            

        

            

                5087
            

            

                
            

            

                
}

            

        

            

                5088
            

            

                
            

            

                

            

        

            

                5089
            

            

                
            

            

                
// Generated as internal constructor for term bor_not.

            

        

            

                5090
            

            

                
            

            

                
pub fn constructor_bor_not<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5091
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5092
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5093
            

            

                
            

            

                
        opcode: Opcode::BorNot,

            

        

            

                5094
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5095
            

            

                
            

            

                
    };

            

        

            

                5096
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5097
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1107.

            

        

            

                5098
            

            

                
            

            

                
    return v6;

            

        

            

                5099
            

            

                
            

            

                
}

            

        

            

                5100
            

            

                
            

            

                

            

        

            

                5101
            

            

                
            

            

                
// Generated as internal constructor for term bxor_not.

            

        

            

                5102
            

            

                
            

            

                
pub fn constructor_bxor_not<C: Context>(

            

        

            

                5103
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5104
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5105
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5106
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5107
            

            

                
            

            

                
) -> Value {

            

        

            

                5108
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5109
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5110
            

            

                
            

            

                
        opcode: Opcode::BxorNot,

            

        

            

                5111
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5112
            

            

                
            

            

                
    };

            

        

            

                5113
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5114
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1116.

            

        

            

                5115
            

            

                
            

            

                
    return v6;

            

        

            

                5116
            

            

                
            

            

                
}

            

        

            

                5117
            

            

                
            

            

                

            

        

            

                5118
            

            

                
            

            

                
// Generated as internal constructor for term band_imm.

            

        

            

                5119
            

            

                
            

            

                
pub fn constructor_band_imm<C: Context>(

            

        

            

                5120
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5121
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5122
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5123
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                5124
            

            

                
            

            

                
) -> Value {

            

        

            

                5125
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                5126
            

            

                
            

            

                
        opcode: Opcode::BandImm,

            

        

            

                5127
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5128
            

            

                
            

            

                
        imm: arg2,

            

        

            

                5129
            

            

                
            

            

                
    };

            

        

            

                5130
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                5131
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1125.

            

        

            

                5132
            

            

                
            

            

                
    return v5;

            

        

            

                5133
            

            

                
            

            

                
}

            

        

            

                5134
            

            

                
            

            

                

            

        

            

                5135
            

            

                
            

            

                
// Generated as internal constructor for term bor_imm.

            

        

            

                5136
            

            

                
            

            

                
pub fn constructor_bor_imm<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Imm64) -> Value {

            

        

            

                5137
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                5138
            

            

                
            

            

                
        opcode: Opcode::BorImm,

            

        

            

                5139
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5140
            

            

                
            

            

                
        imm: arg2,

            

        

            

                5141
            

            

                
            

            

                
    };

            

        

            

                5142
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                5143
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1134.

            

        

            

                5144
            

            

                
            

            

                
    return v5;

            

        

            

                5145
            

            

                
            

            

                
}

            

        

            

                5146
            

            

                
            

            

                

            

        

            

                5147
            

            

                
            

            

                
// Generated as internal constructor for term bxor_imm.

            

        

            

                5148
            

            

                
            

            

                
pub fn constructor_bxor_imm<C: Context>(

            

        

            

                5149
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5150
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5151
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5152
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                5153
            

            

                
            

            

                
) -> Value {

            

        

            

                5154
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                5155
            

            

                
            

            

                
        opcode: Opcode::BxorImm,

            

        

            

                5156
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5157
            

            

                
            

            

                
        imm: arg2,

            

        

            

                5158
            

            

                
            

            

                
    };

            

        

            

                5159
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                5160
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1143.

            

        

            

                5161
            

            

                
            

            

                
    return v5;

            

        

            

                5162
            

            

                
            

            

                
}

            

        

            

                5163
            

            

                
            

            

                

            

        

            

                5164
            

            

                
            

            

                
// Generated as internal constructor for term rotl.

            

        

            

                5165
            

            

                
            

            

                
pub fn constructor_rotl<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5166
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5167
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5168
            

            

                
            

            

                
        opcode: Opcode::Rotl,

            

        

            

                5169
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5170
            

            

                
            

            

                
    };

            

        

            

                5171
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5172
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1152.

            

        

            

                5173
            

            

                
            

            

                
    return v6;

            

        

            

                5174
            

            

                
            

            

                
}

            

        

            

                5175
            

            

                
            

            

                

            

        

            

                5176
            

            

                
            

            

                
// Generated as internal constructor for term rotr.

            

        

            

                5177
            

            

                
            

            

                
pub fn constructor_rotr<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5178
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5179
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5180
            

            

                
            

            

                
        opcode: Opcode::Rotr,

            

        

            

                5181
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5182
            

            

                
            

            

                
    };

            

        

            

                5183
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5184
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1161.

            

        

            

                5185
            

            

                
            

            

                
    return v6;

            

        

            

                5186
            

            

                
            

            

                
}

            

        

            

                5187
            

            

                
            

            

                

            

        

            

                5188
            

            

                
            

            

                
// Generated as internal constructor for term rotl_imm.

            

        

            

                5189
            

            

                
            

            

                
pub fn constructor_rotl_imm<C: Context>(

            

        

            

                5190
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5191
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5192
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5193
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                5194
            

            

                
            

            

                
) -> Value {

            

        

            

                5195
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                5196
            

            

                
            

            

                
        opcode: Opcode::RotlImm,

            

        

            

                5197
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5198
            

            

                
            

            

                
        imm: arg2,

            

        

            

                5199
            

            

                
            

            

                
    };

            

        

            

                5200
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                5201
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1170.

            

        

            

                5202
            

            

                
            

            

                
    return v5;

            

        

            

                5203
            

            

                
            

            

                
}

            

        

            

                5204
            

            

                
            

            

                

            

        

            

                5205
            

            

                
            

            

                
// Generated as internal constructor for term rotr_imm.

            

        

            

                5206
            

            

                
            

            

                
pub fn constructor_rotr_imm<C: Context>(

            

        

            

                5207
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5208
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5209
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5210
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                5211
            

            

                
            

            

                
) -> Value {

            

        

            

                5212
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                5213
            

            

                
            

            

                
        opcode: Opcode::RotrImm,

            

        

            

                5214
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5215
            

            

                
            

            

                
        imm: arg2,

            

        

            

                5216
            

            

                
            

            

                
    };

            

        

            

                5217
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                5218
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1179.

            

        

            

                5219
            

            

                
            

            

                
    return v5;

            

        

            

                5220
            

            

                
            

            

                
}

            

        

            

                5221
            

            

                
            

            

                

            

        

            

                5222
            

            

                
            

            

                
// Generated as internal constructor for term ishl.

            

        

            

                5223
            

            

                
            

            

                
pub fn constructor_ishl<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5224
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5225
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5226
            

            

                
            

            

                
        opcode: Opcode::Ishl,

            

        

            

                5227
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5228
            

            

                
            

            

                
    };

            

        

            

                5229
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5230
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1188.

            

        

            

                5231
            

            

                
            

            

                
    return v6;

            

        

            

                5232
            

            

                
            

            

                
}

            

        

            

                5233
            

            

                
            

            

                

            

        

            

                5234
            

            

                
            

            

                
// Generated as internal constructor for term ushr.

            

        

            

                5235
            

            

                
            

            

                
pub fn constructor_ushr<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5236
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5237
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5238
            

            

                
            

            

                
        opcode: Opcode::Ushr,

            

        

            

                5239
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5240
            

            

                
            

            

                
    };

            

        

            

                5241
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5242
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1197.

            

        

            

                5243
            

            

                
            

            

                
    return v6;

            

        

            

                5244
            

            

                
            

            

                
}

            

        

            

                5245
            

            

                
            

            

                

            

        

            

                5246
            

            

                
            

            

                
// Generated as internal constructor for term sshr.

            

        

            

                5247
            

            

                
            

            

                
pub fn constructor_sshr<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5248
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5249
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5250
            

            

                
            

            

                
        opcode: Opcode::Sshr,

            

        

            

                5251
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5252
            

            

                
            

            

                
    };

            

        

            

                5253
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5254
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1206.

            

        

            

                5255
            

            

                
            

            

                
    return v6;

            

        

            

                5256
            

            

                
            

            

                
}

            

        

            

                5257
            

            

                
            

            

                

            

        

            

                5258
            

            

                
            

            

                
// Generated as internal constructor for term ishl_imm.

            

        

            

                5259
            

            

                
            

            

                
pub fn constructor_ishl_imm<C: Context>(

            

        

            

                5260
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5261
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5262
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5263
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                5264
            

            

                
            

            

                
) -> Value {

            

        

            

                5265
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                5266
            

            

                
            

            

                
        opcode: Opcode::IshlImm,

            

        

            

                5267
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5268
            

            

                
            

            

                
        imm: arg2,

            

        

            

                5269
            

            

                
            

            

                
    };

            

        

            

                5270
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                5271
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1215.

            

        

            

                5272
            

            

                
            

            

                
    return v5;

            

        

            

                5273
            

            

                
            

            

                
}

            

        

            

                5274
            

            

                
            

            

                

            

        

            

                5275
            

            

                
            

            

                
// Generated as internal constructor for term ushr_imm.

            

        

            

                5276
            

            

                
            

            

                
pub fn constructor_ushr_imm<C: Context>(

            

        

            

                5277
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5278
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5279
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5280
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                5281
            

            

                
            

            

                
) -> Value {

            

        

            

                5282
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                5283
            

            

                
            

            

                
        opcode: Opcode::UshrImm,

            

        

            

                5284
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5285
            

            

                
            

            

                
        imm: arg2,

            

        

            

                5286
            

            

                
            

            

                
    };

            

        

            

                5287
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                5288
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1224.

            

        

            

                5289
            

            

                
            

            

                
    return v5;

            

        

            

                5290
            

            

                
            

            

                
}

            

        

            

                5291
            

            

                
            

            

                

            

        

            

                5292
            

            

                
            

            

                
// Generated as internal constructor for term sshr_imm.

            

        

            

                5293
            

            

                
            

            

                
pub fn constructor_sshr_imm<C: Context>(

            

        

            

                5294
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5295
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5296
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5297
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                5298
            

            

                
            

            

                
) -> Value {

            

        

            

                5299
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                5300
            

            

                
            

            

                
        opcode: Opcode::SshrImm,

            

        

            

                5301
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5302
            

            

                
            

            

                
        imm: arg2,

            

        

            

                5303
            

            

                
            

            

                
    };

            

        

            

                5304
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                5305
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1233.

            

        

            

                5306
            

            

                
            

            

                
    return v5;

            

        

            

                5307
            

            

                
            

            

                
}

            

        

            

                5308
            

            

                
            

            

                

            

        

            

                5309
            

            

                
            

            

                
// Generated as internal constructor for term bitrev.

            

        

            

                5310
            

            

                
            

            

                
pub fn constructor_bitrev<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5311
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5312
            

            

                
            

            

                
        opcode: Opcode::Bitrev,

            

        

            

                5313
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5314
            

            

                
            

            

                
    };

            

        

            

                5315
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5316
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1242.

            

        

            

                5317
            

            

                
            

            

                
    return v4;

            

        

            

                5318
            

            

                
            

            

                
}

            

        

            

                5319
            

            

                
            

            

                

            

        

            

                5320
            

            

                
            

            

                
// Generated as internal constructor for term clz.

            

        

            

                5321
            

            

                
            

            

                
pub fn constructor_clz<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5322
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5323
            

            

                
            

            

                
        opcode: Opcode::Clz,

            

        

            

                5324
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5325
            

            

                
            

            

                
    };

            

        

            

                5326
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5327
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1251.

            

        

            

                5328
            

            

                
            

            

                
    return v4;

            

        

            

                5329
            

            

                
            

            

                
}

            

        

            

                5330
            

            

                
            

            

                

            

        

            

                5331
            

            

                
            

            

                
// Generated as internal constructor for term cls.

            

        

            

                5332
            

            

                
            

            

                
pub fn constructor_cls<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5333
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5334
            

            

                
            

            

                
        opcode: Opcode::Cls,

            

        

            

                5335
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5336
            

            

                
            

            

                
    };

            

        

            

                5337
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5338
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1260.

            

        

            

                5339
            

            

                
            

            

                
    return v4;

            

        

            

                5340
            

            

                
            

            

                
}

            

        

            

                5341
            

            

                
            

            

                

            

        

            

                5342
            

            

                
            

            

                
// Generated as internal constructor for term ctz.

            

        

            

                5343
            

            

                
            

            

                
pub fn constructor_ctz<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5344
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5345
            

            

                
            

            

                
        opcode: Opcode::Ctz,

            

        

            

                5346
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5347
            

            

                
            

            

                
    };

            

        

            

                5348
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5349
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1269.

            

        

            

                5350
            

            

                
            

            

                
    return v4;

            

        

            

                5351
            

            

                
            

            

                
}

            

        

            

                5352
            

            

                
            

            

                

            

        

            

                5353
            

            

                
            

            

                
// Generated as internal constructor for term bswap.

            

        

            

                5354
            

            

                
            

            

                
pub fn constructor_bswap<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5355
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5356
            

            

                
            

            

                
        opcode: Opcode::Bswap,

            

        

            

                5357
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5358
            

            

                
            

            

                
    };

            

        

            

                5359
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5360
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1278.

            

        

            

                5361
            

            

                
            

            

                
    return v4;

            

        

            

                5362
            

            

                
            

            

                
}

            

        

            

                5363
            

            

                
            

            

                

            

        

            

                5364
            

            

                
            

            

                
// Generated as internal constructor for term popcnt.

            

        

            

                5365
            

            

                
            

            

                
pub fn constructor_popcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5366
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5367
            

            

                
            

            

                
        opcode: Opcode::Popcnt,

            

        

            

                5368
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5369
            

            

                
            

            

                
    };

            

        

            

                5370
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5371
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1287.

            

        

            

                5372
            

            

                
            

            

                
    return v4;

            

        

            

                5373
            

            

                
            

            

                
}

            

        

            

                5374
            

            

                
            

            

                

            

        

            

                5375
            

            

                
            

            

                
// Generated as internal constructor for term fcmp.

            

        

            

                5376
            

            

                
            

            

                
pub fn constructor_fcmp<C: Context>(

            

        

            

                5377
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5378
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5379
            

            

                
            

            

                
    arg1: &FloatCC,

            

        

            

                5380
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5381
            

            

                
            

            

                
    arg3: Value,

            

        

            

                5382
            

            

                
            

            

                
) -> Value {

            

        

            

                5383
            

            

                
            

            

                
    let v5 = &C::value_array_2_ctor(ctx, arg2, arg3);

            

        

            

                5384
            

            

                
            

            

                
    let v6 = InstructionData::FloatCompare {

            

        

            

                5385
            

            

                
            

            

                
        opcode: Opcode::Fcmp,

            

        

            

                5386
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                5387
            

            

                
            

            

                
        cond: arg1.clone(),

            

        

            

                5388
            

            

                
            

            

                
    };

            

        

            

                5389
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                5390
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1296.

            

        

            

                5391
            

            

                
            

            

                
    return v7;

            

        

            

                5392
            

            

                
            

            

                
}

            

        

            

                5393
            

            

                
            

            

                

            

        

            

                5394
            

            

                
            

            

                
// Generated as internal constructor for term fadd.

            

        

            

                5395
            

            

                
            

            

                
pub fn constructor_fadd<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5396
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5397
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5398
            

            

                
            

            

                
        opcode: Opcode::Fadd,

            

        

            

                5399
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5400
            

            

                
            

            

                
    };

            

        

            

                5401
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5402
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1305.

            

        

            

                5403
            

            

                
            

            

                
    return v6;

            

        

            

                5404
            

            

                
            

            

                
}

            

        

            

                5405
            

            

                
            

            

                

            

        

            

                5406
            

            

                
            

            

                
// Generated as internal constructor for term fsub.

            

        

            

                5407
            

            

                
            

            

                
pub fn constructor_fsub<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5408
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5409
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5410
            

            

                
            

            

                
        opcode: Opcode::Fsub,

            

        

            

                5411
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5412
            

            

                
            

            

                
    };

            

        

            

                5413
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5414
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1314.

            

        

            

                5415
            

            

                
            

            

                
    return v6;

            

        

            

                5416
            

            

                
            

            

                
}

            

        

            

                5417
            

            

                
            

            

                

            

        

            

                5418
            

            

                
            

            

                
// Generated as internal constructor for term fmul.

            

        

            

                5419
            

            

                
            

            

                
pub fn constructor_fmul<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5420
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5421
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5422
            

            

                
            

            

                
        opcode: Opcode::Fmul,

            

        

            

                5423
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5424
            

            

                
            

            

                
    };

            

        

            

                5425
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5426
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1323.

            

        

            

                5427
            

            

                
            

            

                
    return v6;

            

        

            

                5428
            

            

                
            

            

                
}

            

        

            

                5429
            

            

                
            

            

                

            

        

            

                5430
            

            

                
            

            

                
// Generated as internal constructor for term fdiv.

            

        

            

                5431
            

            

                
            

            

                
pub fn constructor_fdiv<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5432
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5433
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5434
            

            

                
            

            

                
        opcode: Opcode::Fdiv,

            

        

            

                5435
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5436
            

            

                
            

            

                
    };

            

        

            

                5437
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5438
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1332.

            

        

            

                5439
            

            

                
            

            

                
    return v6;

            

        

            

                5440
            

            

                
            

            

                
}

            

        

            

                5441
            

            

                
            

            

                

            

        

            

                5442
            

            

                
            

            

                
// Generated as internal constructor for term sqrt.

            

        

            

                5443
            

            

                
            

            

                
pub fn constructor_sqrt<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5444
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5445
            

            

                
            

            

                
        opcode: Opcode::Sqrt,

            

        

            

                5446
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5447
            

            

                
            

            

                
    };

            

        

            

                5448
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5449
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1341.

            

        

            

                5450
            

            

                
            

            

                
    return v4;

            

        

            

                5451
            

            

                
            

            

                
}

            

        

            

                5452
            

            

                
            

            

                

            

        

            

                5453
            

            

                
            

            

                
// Generated as internal constructor for term fma.

            

        

            

                5454
            

            

                
            

            

                
pub fn constructor_fma<C: Context>(

            

        

            

                5455
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5456
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5457
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5458
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5459
            

            

                
            

            

                
    arg3: Value,

            

        

            

                5460
            

            

                
            

            

                
) -> Value {

            

        

            

                5461
            

            

                
            

            

                
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);

            

        

            

                5462
            

            

                
            

            

                
    let v6 = InstructionData::Ternary {

            

        

            

                5463
            

            

                
            

            

                
        opcode: Opcode::Fma,

            

        

            

                5464
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                5465
            

            

                
            

            

                
    };

            

        

            

                5466
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                5467
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1350.

            

        

            

                5468
            

            

                
            

            

                
    return v7;

            

        

            

                5469
            

            

                
            

            

                
}

            

        

            

                5470
            

            

                
            

            

                

            

        

            

                5471
            

            

                
            

            

                
// Generated as internal constructor for term fneg.

            

        

            

                5472
            

            

                
            

            

                
pub fn constructor_fneg<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5473
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5474
            

            

                
            

            

                
        opcode: Opcode::Fneg,

            

        

            

                5475
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5476
            

            

                
            

            

                
    };

            

        

            

                5477
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5478
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1359.

            

        

            

                5479
            

            

                
            

            

                
    return v4;

            

        

            

                5480
            

            

                
            

            

                
}

            

        

            

                5481
            

            

                
            

            

                

            

        

            

                5482
            

            

                
            

            

                
// Generated as internal constructor for term fabs.

            

        

            

                5483
            

            

                
            

            

                
pub fn constructor_fabs<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5484
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5485
            

            

                
            

            

                
        opcode: Opcode::Fabs,

            

        

            

                5486
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5487
            

            

                
            

            

                
    };

            

        

            

                5488
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5489
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1368.

            

        

            

                5490
            

            

                
            

            

                
    return v4;

            

        

            

                5491
            

            

                
            

            

                
}

            

        

            

                5492
            

            

                
            

            

                

            

        

            

                5493
            

            

                
            

            

                
// Generated as internal constructor for term fcopysign.

            

        

            

                5494
            

            

                
            

            

                
pub fn constructor_fcopysign<C: Context>(

            

        

            

                5495
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5496
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5497
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5498
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5499
            

            

                
            

            

                
) -> Value {

            

        

            

                5500
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5501
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5502
            

            

                
            

            

                
        opcode: Opcode::Fcopysign,

            

        

            

                5503
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5504
            

            

                
            

            

                
    };

            

        

            

                5505
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5506
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1377.

            

        

            

                5507
            

            

                
            

            

                
    return v6;

            

        

            

                5508
            

            

                
            

            

                
}

            

        

            

                5509
            

            

                
            

            

                

            

        

            

                5510
            

            

                
            

            

                
// Generated as internal constructor for term fmin.

            

        

            

                5511
            

            

                
            

            

                
pub fn constructor_fmin<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5512
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5513
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5514
            

            

                
            

            

                
        opcode: Opcode::Fmin,

            

        

            

                5515
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5516
            

            

                
            

            

                
    };

            

        

            

                5517
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5518
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1386.

            

        

            

                5519
            

            

                
            

            

                
    return v6;

            

        

            

                5520
            

            

                
            

            

                
}

            

        

            

                5521
            

            

                
            

            

                

            

        

            

                5522
            

            

                
            

            

                
// Generated as internal constructor for term fmin_pseudo.

            

        

            

                5523
            

            

                
            

            

                
pub fn constructor_fmin_pseudo<C: Context>(

            

        

            

                5524
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5525
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5526
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5527
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5528
            

            

                
            

            

                
) -> Value {

            

        

            

                5529
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5530
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5531
            

            

                
            

            

                
        opcode: Opcode::FminPseudo,

            

        

            

                5532
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5533
            

            

                
            

            

                
    };

            

        

            

                5534
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5535
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1395.

            

        

            

                5536
            

            

                
            

            

                
    return v6;

            

        

            

                5537
            

            

                
            

            

                
}

            

        

            

                5538
            

            

                
            

            

                

            

        

            

                5539
            

            

                
            

            

                
// Generated as internal constructor for term fmax.

            

        

            

                5540
            

            

                
            

            

                
pub fn constructor_fmax<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5541
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5542
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5543
            

            

                
            

            

                
        opcode: Opcode::Fmax,

            

        

            

                5544
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5545
            

            

                
            

            

                
    };

            

        

            

                5546
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5547
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1404.

            

        

            

                5548
            

            

                
            

            

                
    return v6;

            

        

            

                5549
            

            

                
            

            

                
}

            

        

            

                5550
            

            

                
            

            

                

            

        

            

                5551
            

            

                
            

            

                
// Generated as internal constructor for term fmax_pseudo.

            

        

            

                5552
            

            

                
            

            

                
pub fn constructor_fmax_pseudo<C: Context>(

            

        

            

                5553
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5554
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5555
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5556
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5557
            

            

                
            

            

                
) -> Value {

            

        

            

                5558
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5559
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5560
            

            

                
            

            

                
        opcode: Opcode::FmaxPseudo,

            

        

            

                5561
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5562
            

            

                
            

            

                
    };

            

        

            

                5563
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5564
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1413.

            

        

            

                5565
            

            

                
            

            

                
    return v6;

            

        

            

                5566
            

            

                
            

            

                
}

            

        

            

                5567
            

            

                
            

            

                

            

        

            

                5568
            

            

                
            

            

                
// Generated as internal constructor for term ceil.

            

        

            

                5569
            

            

                
            

            

                
pub fn constructor_ceil<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5570
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5571
            

            

                
            

            

                
        opcode: Opcode::Ceil,

            

        

            

                5572
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5573
            

            

                
            

            

                
    };

            

        

            

                5574
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5575
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1422.

            

        

            

                5576
            

            

                
            

            

                
    return v4;

            

        

            

                5577
            

            

                
            

            

                
}

            

        

            

                5578
            

            

                
            

            

                

            

        

            

                5579
            

            

                
            

            

                
// Generated as internal constructor for term floor.

            

        

            

                5580
            

            

                
            

            

                
pub fn constructor_floor<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5581
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5582
            

            

                
            

            

                
        opcode: Opcode::Floor,

            

        

            

                5583
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5584
            

            

                
            

            

                
    };

            

        

            

                5585
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5586
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1431.

            

        

            

                5587
            

            

                
            

            

                
    return v4;

            

        

            

                5588
            

            

                
            

            

                
}

            

        

            

                5589
            

            

                
            

            

                

            

        

            

                5590
            

            

                
            

            

                
// Generated as internal constructor for term trunc.

            

        

            

                5591
            

            

                
            

            

                
pub fn constructor_trunc<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5592
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5593
            

            

                
            

            

                
        opcode: Opcode::Trunc,

            

        

            

                5594
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5595
            

            

                
            

            

                
    };

            

        

            

                5596
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5597
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1440.

            

        

            

                5598
            

            

                
            

            

                
    return v4;

            

        

            

                5599
            

            

                
            

            

                
}

            

        

            

                5600
            

            

                
            

            

                

            

        

            

                5601
            

            

                
            

            

                
// Generated as internal constructor for term nearest.

            

        

            

                5602
            

            

                
            

            

                
pub fn constructor_nearest<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5603
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5604
            

            

                
            

            

                
        opcode: Opcode::Nearest,

            

        

            

                5605
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5606
            

            

                
            

            

                
    };

            

        

            

                5607
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5608
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1449.

            

        

            

                5609
            

            

                
            

            

                
    return v4;

            

        

            

                5610
            

            

                
            

            

                
}

            

        

            

                5611
            

            

                
            

            

                

            

        

            

                5612
            

            

                
            

            

                
// Generated as internal constructor for term is_null.

            

        

            

                5613
            

            

                
            

            

                
pub fn constructor_is_null<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5614
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5615
            

            

                
            

            

                
        opcode: Opcode::IsNull,

            

        

            

                5616
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5617
            

            

                
            

            

                
    };

            

        

            

                5618
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5619
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1458.

            

        

            

                5620
            

            

                
            

            

                
    return v4;

            

        

            

                5621
            

            

                
            

            

                
}

            

        

            

                5622
            

            

                
            

            

                

            

        

            

                5623
            

            

                
            

            

                
// Generated as internal constructor for term is_invalid.

            

        

            

                5624
            

            

                
            

            

                
pub fn constructor_is_invalid<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5625
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5626
            

            

                
            

            

                
        opcode: Opcode::IsInvalid,

            

        

            

                5627
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5628
            

            

                
            

            

                
    };

            

        

            

                5629
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5630
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1467.

            

        

            

                5631
            

            

                
            

            

                
    return v4;

            

        

            

                5632
            

            

                
            

            

                
}

            

        

            

                5633
            

            

                
            

            

                

            

        

            

                5634
            

            

                
            

            

                
// Generated as internal constructor for term bitcast.

            

        

            

                5635
            

            

                
            

            

                
pub fn constructor_bitcast<C: Context>(

            

        

            

                5636
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5637
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5638
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                5639
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5640
            

            

                
            

            

                
) -> Value {

            

        

            

                5641
            

            

                
            

            

                
    let v4 = InstructionData::LoadNoOffset {

            

        

            

                5642
            

            

                
            

            

                
        opcode: Opcode::Bitcast,

            

        

            

                5643
            

            

                
            

            

                
        arg: arg2,

            

        

            

                5644
            

            

                
            

            

                
        flags: arg1,

            

        

            

                5645
            

            

                
            

            

                
    };

            

        

            

                5646
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                5647
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1476.

            

        

            

                5648
            

            

                
            

            

                
    return v5;

            

        

            

                5649
            

            

                
            

            

                
}

            

        

            

                5650
            

            

                
            

            

                

            

        

            

                5651
            

            

                
            

            

                
// Generated as internal constructor for term scalar_to_vector.

            

        

            

                5652
            

            

                
            

            

                
pub fn constructor_scalar_to_vector<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5653
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5654
            

            

                
            

            

                
        opcode: Opcode::ScalarToVector,

            

        

            

                5655
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5656
            

            

                
            

            

                
    };

            

        

            

                5657
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5658
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1485.

            

        

            

                5659
            

            

                
            

            

                
    return v4;

            

        

            

                5660
            

            

                
            

            

                
}

            

        

            

                5661
            

            

                
            

            

                

            

        

            

                5662
            

            

                
            

            

                
// Generated as internal constructor for term bmask.

            

        

            

                5663
            

            

                
            

            

                
pub fn constructor_bmask<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5664
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5665
            

            

                
            

            

                
        opcode: Opcode::Bmask,

            

        

            

                5666
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5667
            

            

                
            

            

                
    };

            

        

            

                5668
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5669
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1494.

            

        

            

                5670
            

            

                
            

            

                
    return v4;

            

        

            

                5671
            

            

                
            

            

                
}

            

        

            

                5672
            

            

                
            

            

                

            

        

            

                5673
            

            

                
            

            

                
// Generated as internal constructor for term ireduce.

            

        

            

                5674
            

            

                
            

            

                
pub fn constructor_ireduce<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5675
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5676
            

            

                
            

            

                
        opcode: Opcode::Ireduce,

            

        

            

                5677
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5678
            

            

                
            

            

                
    };

            

        

            

                5679
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5680
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1503.

            

        

            

                5681
            

            

                
            

            

                
    return v4;

            

        

            

                5682
            

            

                
            

            

                
}

            

        

            

                5683
            

            

                
            

            

                

            

        

            

                5684
            

            

                
            

            

                
// Generated as internal constructor for term snarrow.

            

        

            

                5685
            

            

                
            

            

                
pub fn constructor_snarrow<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5686
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5687
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5688
            

            

                
            

            

                
        opcode: Opcode::Snarrow,

            

        

            

                5689
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5690
            

            

                
            

            

                
    };

            

        

            

                5691
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5692
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1512.

            

        

            

                5693
            

            

                
            

            

                
    return v6;

            

        

            

                5694
            

            

                
            

            

                
}

            

        

            

                5695
            

            

                
            

            

                

            

        

            

                5696
            

            

                
            

            

                
// Generated as internal constructor for term unarrow.

            

        

            

                5697
            

            

                
            

            

                
pub fn constructor_unarrow<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5698
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5699
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5700
            

            

                
            

            

                
        opcode: Opcode::Unarrow,

            

        

            

                5701
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5702
            

            

                
            

            

                
    };

            

        

            

                5703
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5704
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1521.

            

        

            

                5705
            

            

                
            

            

                
    return v6;

            

        

            

                5706
            

            

                
            

            

                
}

            

        

            

                5707
            

            

                
            

            

                

            

        

            

                5708
            

            

                
            

            

                
// Generated as internal constructor for term uunarrow.

            

        

            

                5709
            

            

                
            

            

                
pub fn constructor_uunarrow<C: Context>(

            

        

            

                5710
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5711
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5712
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5713
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5714
            

            

                
            

            

                
) -> Value {

            

        

            

                5715
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5716
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5717
            

            

                
            

            

                
        opcode: Opcode::Uunarrow,

            

        

            

                5718
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5719
            

            

                
            

            

                
    };

            

        

            

                5720
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5721
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1530.

            

        

            

                5722
            

            

                
            

            

                
    return v6;

            

        

            

                5723
            

            

                
            

            

                
}

            

        

            

                5724
            

            

                
            

            

                

            

        

            

                5725
            

            

                
            

            

                
// Generated as internal constructor for term swiden_low.

            

        

            

                5726
            

            

                
            

            

                
pub fn constructor_swiden_low<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5727
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5728
            

            

                
            

            

                
        opcode: Opcode::SwidenLow,

            

        

            

                5729
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5730
            

            

                
            

            

                
    };

            

        

            

                5731
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5732
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1539.

            

        

            

                5733
            

            

                
            

            

                
    return v4;

            

        

            

                5734
            

            

                
            

            

                
}

            

        

            

                5735
            

            

                
            

            

                

            

        

            

                5736
            

            

                
            

            

                
// Generated as internal constructor for term swiden_high.

            

        

            

                5737
            

            

                
            

            

                
pub fn constructor_swiden_high<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5738
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5739
            

            

                
            

            

                
        opcode: Opcode::SwidenHigh,

            

        

            

                5740
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5741
            

            

                
            

            

                
    };

            

        

            

                5742
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5743
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1548.

            

        

            

                5744
            

            

                
            

            

                
    return v4;

            

        

            

                5745
            

            

                
            

            

                
}

            

        

            

                5746
            

            

                
            

            

                

            

        

            

                5747
            

            

                
            

            

                
// Generated as internal constructor for term uwiden_low.

            

        

            

                5748
            

            

                
            

            

                
pub fn constructor_uwiden_low<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5749
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5750
            

            

                
            

            

                
        opcode: Opcode::UwidenLow,

            

        

            

                5751
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5752
            

            

                
            

            

                
    };

            

        

            

                5753
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5754
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1557.

            

        

            

                5755
            

            

                
            

            

                
    return v4;

            

        

            

                5756
            

            

                
            

            

                
}

            

        

            

                5757
            

            

                
            

            

                

            

        

            

                5758
            

            

                
            

            

                
// Generated as internal constructor for term uwiden_high.

            

        

            

                5759
            

            

                
            

            

                
pub fn constructor_uwiden_high<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5760
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5761
            

            

                
            

            

                
        opcode: Opcode::UwidenHigh,

            

        

            

                5762
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5763
            

            

                
            

            

                
    };

            

        

            

                5764
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5765
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1566.

            

        

            

                5766
            

            

                
            

            

                
    return v4;

            

        

            

                5767
            

            

                
            

            

                
}

            

        

            

                5768
            

            

                
            

            

                

            

        

            

                5769
            

            

                
            

            

                
// Generated as internal constructor for term iadd_pairwise.

            

        

            

                5770
            

            

                
            

            

                
pub fn constructor_iadd_pairwise<C: Context>(

            

        

            

                5771
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5772
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5773
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5774
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5775
            

            

                
            

            

                
) -> Value {

            

        

            

                5776
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5777
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5778
            

            

                
            

            

                
        opcode: Opcode::IaddPairwise,

            

        

            

                5779
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5780
            

            

                
            

            

                
    };

            

        

            

                5781
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5782
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1575.

            

        

            

                5783
            

            

                
            

            

                
    return v6;

            

        

            

                5784
            

            

                
            

            

                
}

            

        

            

                5785
            

            

                
            

            

                

            

        

            

                5786
            

            

                
            

            

                
// Generated as internal constructor for term x86_pmaddubsw.

            

        

            

                5787
            

            

                
            

            

                
pub fn constructor_x86_pmaddubsw<C: Context>(

            

        

            

                5788
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5789
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5790
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5791
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5792
            

            

                
            

            

                
) -> Value {

            

        

            

                5793
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5794
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5795
            

            

                
            

            

                
        opcode: Opcode::X86Pmaddubsw,

            

        

            

                5796
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5797
            

            

                
            

            

                
    };

            

        

            

                5798
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5799
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1584.

            

        

            

                5800
            

            

                
            

            

                
    return v6;

            

        

            

                5801
            

            

                
            

            

                
}

            

        

            

                5802
            

            

                
            

            

                

            

        

            

                5803
            

            

                
            

            

                
// Generated as internal constructor for term uextend.

            

        

            

                5804
            

            

                
            

            

                
pub fn constructor_uextend<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5805
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5806
            

            

                
            

            

                
        opcode: Opcode::Uextend,

            

        

            

                5807
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5808
            

            

                
            

            

                
    };

            

        

            

                5809
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5810
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1593.

            

        

            

                5811
            

            

                
            

            

                
    return v4;

            

        

            

                5812
            

            

                
            

            

                
}

            

        

            

                5813
            

            

                
            

            

                

            

        

            

                5814
            

            

                
            

            

                
// Generated as internal constructor for term sextend.

            

        

            

                5815
            

            

                
            

            

                
pub fn constructor_sextend<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5816
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5817
            

            

                
            

            

                
        opcode: Opcode::Sextend,

            

        

            

                5818
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5819
            

            

                
            

            

                
    };

            

        

            

                5820
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5821
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1602.

            

        

            

                5822
            

            

                
            

            

                
    return v4;

            

        

            

                5823
            

            

                
            

            

                
}

            

        

            

                5824
            

            

                
            

            

                

            

        

            

                5825
            

            

                
            

            

                
// Generated as internal constructor for term fpromote.

            

        

            

                5826
            

            

                
            

            

                
pub fn constructor_fpromote<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5827
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5828
            

            

                
            

            

                
        opcode: Opcode::Fpromote,

            

        

            

                5829
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5830
            

            

                
            

            

                
    };

            

        

            

                5831
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5832
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1611.

            

        

            

                5833
            

            

                
            

            

                
    return v4;

            

        

            

                5834
            

            

                
            

            

                
}

            

        

            

                5835
            

            

                
            

            

                

            

        

            

                5836
            

            

                
            

            

                
// Generated as internal constructor for term fdemote.

            

        

            

                5837
            

            

                
            

            

                
pub fn constructor_fdemote<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5838
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5839
            

            

                
            

            

                
        opcode: Opcode::Fdemote,

            

        

            

                5840
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5841
            

            

                
            

            

                
    };

            

        

            

                5842
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5843
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1620.

            

        

            

                5844
            

            

                
            

            

                
    return v4;

            

        

            

                5845
            

            

                
            

            

                
}

            

        

            

                5846
            

            

                
            

            

                

            

        

            

                5847
            

            

                
            

            

                
// Generated as internal constructor for term fvdemote.

            

        

            

                5848
            

            

                
            

            

                
pub fn constructor_fvdemote<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5849
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5850
            

            

                
            

            

                
        opcode: Opcode::Fvdemote,

            

        

            

                5851
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5852
            

            

                
            

            

                
    };

            

        

            

                5853
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5854
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1629.

            

        

            

                5855
            

            

                
            

            

                
    return v4;

            

        

            

                5856
            

            

                
            

            

                
}

            

        

            

                5857
            

            

                
            

            

                

            

        

            

                5858
            

            

                
            

            

                
// Generated as internal constructor for term fvpromote_low.

            

        

            

                5859
            

            

                
            

            

                
pub fn constructor_fvpromote_low<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5860
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5861
            

            

                
            

            

                
        opcode: Opcode::FvpromoteLow,

            

        

            

                5862
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5863
            

            

                
            

            

                
    };

            

        

            

                5864
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5865
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1638.

            

        

            

                5866
            

            

                
            

            

                
    return v4;

            

        

            

                5867
            

            

                
            

            

                
}

            

        

            

                5868
            

            

                
            

            

                

            

        

            

                5869
            

            

                
            

            

                
// Generated as internal constructor for term fcvt_to_uint.

            

        

            

                5870
            

            

                
            

            

                
pub fn constructor_fcvt_to_uint<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5871
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5872
            

            

                
            

            

                
        opcode: Opcode::FcvtToUint,

            

        

            

                5873
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5874
            

            

                
            

            

                
    };

            

        

            

                5875
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5876
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1647.

            

        

            

                5877
            

            

                
            

            

                
    return v4;

            

        

            

                5878
            

            

                
            

            

                
}

            

        

            

                5879
            

            

                
            

            

                

            

        

            

                5880
            

            

                
            

            

                
// Generated as internal constructor for term fcvt_to_sint.

            

        

            

                5881
            

            

                
            

            

                
pub fn constructor_fcvt_to_sint<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5882
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5883
            

            

                
            

            

                
        opcode: Opcode::FcvtToSint,

            

        

            

                5884
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5885
            

            

                
            

            

                
    };

            

        

            

                5886
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5887
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1656.

            

        

            

                5888
            

            

                
            

            

                
    return v4;

            

        

            

                5889
            

            

                
            

            

                
}

            

        

            

                5890
            

            

                
            

            

                

            

        

            

                5891
            

            

                
            

            

                
// Generated as internal constructor for term fcvt_to_uint_sat.

            

        

            

                5892
            

            

                
            

            

                
pub fn constructor_fcvt_to_uint_sat<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5893
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5894
            

            

                
            

            

                
        opcode: Opcode::FcvtToUintSat,

            

        

            

                5895
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5896
            

            

                
            

            

                
    };

            

        

            

                5897
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5898
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1665.

            

        

            

                5899
            

            

                
            

            

                
    return v4;

            

        

            

                5900
            

            

                
            

            

                
}

            

        

            

                5901
            

            

                
            

            

                

            

        

            

                5902
            

            

                
            

            

                
// Generated as internal constructor for term fcvt_to_sint_sat.

            

        

            

                5903
            

            

                
            

            

                
pub fn constructor_fcvt_to_sint_sat<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5904
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5905
            

            

                
            

            

                
        opcode: Opcode::FcvtToSintSat,

            

        

            

                5906
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5907
            

            

                
            

            

                
    };

            

        

            

                5908
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5909
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1674.

            

        

            

                5910
            

            

                
            

            

                
    return v4;

            

        

            

                5911
            

            

                
            

            

                
}

            

        

            

                5912
            

            

                
            

            

                

            

        

            

                5913
            

            

                
            

            

                
// Generated as internal constructor for term x86_cvtt2dq.

            

        

            

                5914
            

            

                
            

            

                
pub fn constructor_x86_cvtt2dq<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5915
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5916
            

            

                
            

            

                
        opcode: Opcode::X86Cvtt2dq,

            

        

            

                5917
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5918
            

            

                
            

            

                
    };

            

        

            

                5919
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5920
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1683.

            

        

            

                5921
            

            

                
            

            

                
    return v4;

            

        

            

                5922
            

            

                
            

            

                
}

            

        

            

                5923
            

            

                
            

            

                

            

        

            

                5924
            

            

                
            

            

                
// Generated as internal constructor for term fcvt_from_uint.

            

        

            

                5925
            

            

                
            

            

                
pub fn constructor_fcvt_from_uint<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5926
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5927
            

            

                
            

            

                
        opcode: Opcode::FcvtFromUint,

            

        

            

                5928
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5929
            

            

                
            

            

                
    };

            

        

            

                5930
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5931
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1692.

            

        

            

                5932
            

            

                
            

            

                
    return v4;

            

        

            

                5933
            

            

                
            

            

                
}

            

        

            

                5934
            

            

                
            

            

                

            

        

            

                5935
            

            

                
            

            

                
// Generated as internal constructor for term fcvt_from_sint.

            

        

            

                5936
            

            

                
            

            

                
pub fn constructor_fcvt_from_sint<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5937
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5938
            

            

                
            

            

                
        opcode: Opcode::FcvtFromSint,

            

        

            

                5939
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5940
            

            

                
            

            

                
    };

            

        

            

                5941
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5942
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1701.

            

        

            

                5943
            

            

                
            

            

                
    return v4;

            

        

            

                5944
            

            

                
            

            

                
}

            

        

            

                5945
            

            

                
            

            

                

            

        

            

                5946
            

            

                
            

            

                
// Generated as internal constructor for term fcvt_low_from_sint.

            

        

            

                5947
            

            

                
            

            

                
pub fn constructor_fcvt_low_from_sint<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5948
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5949
            

            

                
            

            

                
        opcode: Opcode::FcvtLowFromSint,

            

        

            

                5950
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5951
            

            

                
            

            

                
    };

            

        

            

                5952
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5953
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1710.

            

        

            

                5954
            

            

                
            

            

                
    return v4;

            

        

            

                5955
            

            

                
            

            

                
}

            

        

            

                5956
            

            

                
            

            

                

            

        

            

                5957
            

            

                
            

            

                
// Generated as internal constructor for term iconcat.

            

        

            

                5958
            

            

                
            

            

                
pub fn constructor_iconcat<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5959
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5960
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5961
            

            

                
            

            

                
        opcode: Opcode::Iconcat,

            

        

            

                5962
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5963
            

            

                
            

            

                
    };

            

        

            

                5964
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5965
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1719.

            

        

            

                5966
            

            

                
            

            

                
    return v6;

            

        

            

                5967
            

            

                
            

            

                
}

            

        

            

                5968
            

            

                
            

            

                

            

        

            

                5969
            

            

                
            

            

                
// Generated as internal constructor for term atomic_rmw.

            

        

            

                5970
            

            

                
            

            

                
pub fn constructor_atomic_rmw<C: Context>(

            

        

            

                5971
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5972
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5973
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                5974
            

            

                
            

            

                
    arg2: &AtomicRmwOp,

            

        

            

                5975
            

            

                
            

            

                
    arg3: Value,

            

        

            

                5976
            

            

                
            

            

                
    arg4: Value,

            

        

            

                5977
            

            

                
            

            

                
) -> Value {

            

        

            

                5978
            

            

                
            

            

                
    let v6 = &C::value_array_2_ctor(ctx, arg3, arg4);

            

        

            

                5979
            

            

                
            

            

                
    let v7 = InstructionData::AtomicRmw {

            

        

            

                5980
            

            

                
            

            

                
        opcode: Opcode::AtomicRmw,

            

        

            

                5981
            

            

                
            

            

                
        args: v6.clone(),

            

        

            

                5982
            

            

                
            

            

                
        flags: arg1,

            

        

            

                5983
            

            

                
            

            

                
        op: arg2.clone(),

            

        

            

                5984
            

            

                
            

            

                
    };

            

        

            

                5985
            

            

                
            

            

                
    let v8 = C::make_inst_ctor(ctx, arg0, &v7);

            

        

            

                5986
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1728.

            

        

            

                5987
            

            

                
            

            

                
    return v8;

            

        

            

                5988
            

            

                
            

            

                
}

            

        

            

                5989
            

            

                
            

            

                

            

        

            

                5990
            

            

                
            

            

                
// Generated as internal constructor for term atomic_cas.

            

        

            

                5991
            

            

                
            

            

                
pub fn constructor_atomic_cas<C: Context>(

            

        

            

                5992
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5993
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5994
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                5995
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5996
            

            

                
            

            

                
    arg3: Value,

            

        

            

                5997
            

            

                
            

            

                
    arg4: Value,

            

        

            

                5998
            

            

                
            

            

                
) -> Value {

            

        

            

                5999
            

            

                
            

            

                
    let v6 = &C::value_array_3_ctor(ctx, arg2, arg3, arg4);

            

        

            

                6000
            

            

                
            

            

                
    let v7 = InstructionData::AtomicCas {

            

        

            

                6001
            

            

                
            

            

                
        opcode: Opcode::AtomicCas,

            

        

            

                6002
            

            

                
            

            

                
        args: v6.clone(),

            

        

            

                6003
            

            

                
            

            

                
        flags: arg1,

            

        

            

                6004
            

            

                
            

            

                
    };

            

        

            

                6005
            

            

                
            

            

                
    let v8 = C::make_inst_ctor(ctx, arg0, &v7);

            

        

            

                6006
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1737.

            

        

            

                6007
            

            

                
            

            

                
    return v8;

            

        

            

                6008
            

            

                
            

            

                
}

            

        

            

                6009
            

            

                
            

            

                

            

        

            

                6010
            

            

                
            

            

                
// Generated as internal constructor for term atomic_load.

            

        

            

                6011
            

            

                
            

            

                
pub fn constructor_atomic_load<C: Context>(

            

        

            

                6012
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6013
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6014
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                6015
            

            

                
            

            

                
    arg2: Value,

            

        

            

                6016
            

            

                
            

            

                
) -> Value {

            

        

            

                6017
            

            

                
            

            

                
    let v4 = InstructionData::LoadNoOffset {

            

        

            

                6018
            

            

                
            

            

                
        opcode: Opcode::AtomicLoad,

            

        

            

                6019
            

            

                
            

            

                
        arg: arg2,

            

        

            

                6020
            

            

                
            

            

                
        flags: arg1,

            

        

            

                6021
            

            

                
            

            

                
    };

            

        

            

                6022
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                6023
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1746.

            

        

            

                6024
            

            

                
            

            

                
    return v5;

            

        

            

                6025
            

            

                
            

            

                
}

            

        

            

                6026
            

            

                
            

            

                

            

        

            

                6027
            

            

                
            

            

                
// Generated as internal constructor for term extract_vector.

            

        

            

                6028
            

            

                
            

            

                
pub fn constructor_extract_vector<C: Context>(

            

        

            

                6029
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6030
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6031
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6032
            

            

                
            

            

                
    arg2: Uimm8,

            

        

            

                6033
            

            

                
            

            

                
) -> Value {

            

        

            

                6034
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm8 {

            

        

            

                6035
            

            

                
            

            

                
        opcode: Opcode::ExtractVector,

            

        

            

                6036
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6037
            

            

                
            

            

                
        imm: arg2,

            

        

            

                6038
            

            

                
            

            

                
    };

            

        

            

                6039
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                6040
            

            

                
            

            

                
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1755.

            

        

            

                6041
            

            

                
            

            

                
    return v5;

            

        

            

                6042
            

            

                
            

            

                
}